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", "bbbbbu",
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 * Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to
304 * the requirements sections in BOLT #11
306 export enum Bolt11SemanticError {
308 * The invoice is missing the mandatory payment hash
310 LDKBolt11SemanticError_NoPaymentHash,
312 * The invoice has multiple payment hashes which isn't allowed
314 LDKBolt11SemanticError_MultiplePaymentHashes,
316 * No description or description hash are part of the invoice
318 LDKBolt11SemanticError_NoDescription,
320 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
322 LDKBolt11SemanticError_MultipleDescriptions,
324 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
327 LDKBolt11SemanticError_NoPaymentSecret,
329 * The invoice contains multiple payment secrets
331 LDKBolt11SemanticError_MultiplePaymentSecrets,
333 * The invoice's features are invalid
335 LDKBolt11SemanticError_InvalidFeatures,
337 * The recovery id doesn't fit the signature/pub key
339 LDKBolt11SemanticError_InvalidRecoveryId,
341 * The invoice's signature is invalid
343 LDKBolt11SemanticError_InvalidSignature,
345 * The invoice's amount was not a whole number of millisatoshis
347 LDKBolt11SemanticError_ImpreciseAmount,
352 * Error when interpreting a TLV stream as a specific type.
354 export enum Bolt12SemanticError {
356 * The current [`std::time::SystemTime`] is past the offer or invoice's expiration.
358 LDKBolt12SemanticError_AlreadyExpired,
360 * The provided chain hash does not correspond to a supported chain.
362 LDKBolt12SemanticError_UnsupportedChain,
364 * A chain was provided but was not expected.
366 LDKBolt12SemanticError_UnexpectedChain,
368 * An amount was expected but was missing.
370 LDKBolt12SemanticError_MissingAmount,
372 * The amount exceeded the total bitcoin supply.
374 LDKBolt12SemanticError_InvalidAmount,
376 * An amount was provided but was not sufficient in value.
378 LDKBolt12SemanticError_InsufficientAmount,
380 * An amount was provided but was not expected.
382 LDKBolt12SemanticError_UnexpectedAmount,
384 * A currency was provided that is not supported.
386 LDKBolt12SemanticError_UnsupportedCurrency,
388 * A feature was required but is unknown.
390 LDKBolt12SemanticError_UnknownRequiredFeatures,
392 * Features were provided but were not expected.
394 LDKBolt12SemanticError_UnexpectedFeatures,
396 * A required description was not provided.
398 LDKBolt12SemanticError_MissingDescription,
400 * A signing pubkey was not provided.
402 LDKBolt12SemanticError_MissingSigningPubkey,
404 * A signing pubkey was provided but a different one was expected.
406 LDKBolt12SemanticError_InvalidSigningPubkey,
408 * A signing pubkey was provided but was not expected.
410 LDKBolt12SemanticError_UnexpectedSigningPubkey,
412 * A quantity was expected but was missing.
414 LDKBolt12SemanticError_MissingQuantity,
416 * An unsupported quantity was provided.
418 LDKBolt12SemanticError_InvalidQuantity,
420 * A quantity or quantity bounds was provided but was not expected.
422 LDKBolt12SemanticError_UnexpectedQuantity,
424 * Metadata could not be used to verify the offers message.
426 LDKBolt12SemanticError_InvalidMetadata,
428 * Metadata was provided but was not expected.
430 LDKBolt12SemanticError_UnexpectedMetadata,
432 * Payer metadata was expected but was missing.
434 LDKBolt12SemanticError_MissingPayerMetadata,
436 * A payer id was expected but was missing.
438 LDKBolt12SemanticError_MissingPayerId,
440 * Blinded paths were expected but were missing.
442 LDKBolt12SemanticError_MissingPaths,
444 * The blinded payinfo given does not match the number of blinded path hops.
446 LDKBolt12SemanticError_InvalidPayInfo,
448 * An invoice creation time was expected but was missing.
450 LDKBolt12SemanticError_MissingCreationTime,
452 * An invoice payment hash was expected but was missing.
454 LDKBolt12SemanticError_MissingPaymentHash,
456 * A signature was expected but was missing.
458 LDKBolt12SemanticError_MissingSignature,
463 * An enum which can either contain a or not
465 export enum COption_NoneZ {
467 * When we're in this state, this COption_NoneZ contains a
469 LDKCOption_NoneZ_Some,
471 * When we're in this state, this COption_NoneZ contains nothing
473 LDKCOption_NoneZ_None,
478 * An enum representing the status of a channel monitor update persistence.
480 export enum ChannelMonitorUpdateStatus {
482 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
485 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
486 be available on restart even if the application crashes.
488 LDKChannelMonitorUpdateStatus_Completed,
490 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
491 our state failed, but is expected to succeed at some point in the future).
493 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
494 submitting new commitment transactions to the counterparty. Once the update(s) which failed
495 have been successfully applied, a [`MonitorEvent::Completed`] can be used to restore the
496 channel to an operational state.
498 Note that a given [`ChannelManager`] will *never* re-generate a [`ChannelMonitorUpdate`].
499 If you return this error you must ensure that it is written to disk safely before writing
500 the latest [`ChannelManager`] state, or you should return [`PermanentFailure`] instead.
502 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
503 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
504 attempting to claim it on this channel) and those updates must still be persisted.
506 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
507 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
508 monitor update for the same channel.
510 For deployments where a copy of ChannelMonitors and other local state are backed up in a
511 remote location (with local copies persisted immediately), it is anticipated that all
512 updates will return [`InProgress`] until the remote copies could be updated.
514 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
515 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
516 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
518 LDKChannelMonitorUpdateStatus_InProgress,
520 * Used to indicate no further channel monitor updates will be allowed (likely a disk failure
521 or a remote copy of this [`ChannelMonitor`] is no longer reachable and thus not updatable).
523 When this is returned, [`ChannelManager`] will force-close the channel but *not* broadcast
524 our current commitment transaction. This avoids a dangerous case where a local disk failure
525 (e.g. the Linux-default remounting of the disk as read-only) causes [`PermanentFailure`]s
526 for all monitor updates. If we were to broadcast our latest commitment transaction and then
527 restart, we could end up reading a previous [`ChannelMonitor`] and [`ChannelManager`],
528 revoking our now-broadcasted state before seeing it confirm and losing all our funds.
530 Note that this is somewhat of a tradeoff - if the disk is really gone and we may have lost
531 the data permanently, we really should broadcast immediately. If the data can be recovered
532 with manual intervention, we'd rather close the channel, rejecting future updates to it,
533 and broadcast the latest state only if we have HTLCs to claim which are timing out (which
534 we do as long as blocks are connected).
536 In order to broadcast the latest local commitment transaction, you'll need to call
537 [`ChannelMonitor::get_latest_holder_commitment_txn`] and broadcast the resulting
538 transactions once you've safely ensured no further channel updates can be generated by your
541 Note that at least one final [`ChannelMonitorUpdate`] may still be provided, which must
542 still be processed by a running [`ChannelMonitor`]. This final update will mark the
543 [`ChannelMonitor`] as finalized, ensuring no further updates (e.g. revocation of the latest
544 commitment transaction) are allowed.
546 Note that even if you return a [`PermanentFailure`] due to unavailability of secondary
547 [`ChannelMonitor`] copies, you should still make an attempt to store the update where
548 possible to ensure you can claim HTLC outputs on the latest commitment transaction
551 In case of distributed watchtowers deployment, the new version must be written to disk, as
552 state may have been stored but rejected due to a block forcing a commitment broadcast. This
553 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
554 lagging behind on block processing.
556 [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
557 [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
559 LDKChannelMonitorUpdateStatus_PermanentFailure,
564 * Further information on the details of the channel shutdown.
565 * Upon channels being forced closed (i.e. commitment transaction confirmation detected
566 * by `ChainMonitor`), ChannelShutdownState will be set to `ShutdownComplete` or
567 * the channel will be removed shortly.
568 * Also note, that in normal operation, peers could disconnect at any of these states
569 * and require peer re-connection before making progress onto other states
571 export enum ChannelShutdownState {
573 * Channel has not sent or received a shutdown message.
575 LDKChannelShutdownState_NotShuttingDown,
577 * Local node has sent a shutdown message for this channel.
579 LDKChannelShutdownState_ShutdownInitiated,
581 * Shutdown message exchanges have concluded and the channels are in the midst of
582 resolving all existing open HTLCs before closing can continue.
584 LDKChannelShutdownState_ResolvingHTLCs,
586 * All HTLCs have been resolved, nodes are currently negotiating channel close onchain fee rates.
588 LDKChannelShutdownState_NegotiatingClosingFee,
590 * We've successfully negotiated a closing_signed dance. At this point `ChannelManager` is about
593 LDKChannelShutdownState_ShutdownComplete,
598 * An enum that represents the priority at which we want a transaction to confirm used for feerate
601 export enum ConfirmationTarget {
603 * We'd like a transaction to confirm in the future, but don't want to commit most of the fees
604 required to do so yet. The remaining fees will come via a Child-Pays-For-Parent (CPFP) fee
605 bump of the transaction.
607 The feerate returned should be the absolute minimum feerate required to enter most node
608 mempools across the network. Note that if you are not able to obtain this feerate estimate,
609 you should likely use the furthest-out estimate allowed by your fee estimator.
611 LDKConfirmationTarget_MempoolMinimum,
613 * We are happy with a transaction confirming slowly, at least within a day or so worth of
616 LDKConfirmationTarget_Background,
618 * We'd like a transaction to confirm without major delayed, i.e., within the next 12-24 blocks.
620 LDKConfirmationTarget_Normal,
622 * We'd like a transaction to confirm in the next few blocks.
624 LDKConfirmationTarget_HighPriority,
629 * Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
631 export enum CreationError {
633 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
635 LDKCreationError_DescriptionTooLong,
637 * The specified route has too many hops and can't be encoded
639 LDKCreationError_RouteTooLong,
641 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
643 LDKCreationError_TimestampOutOfBounds,
645 * The supplied millisatoshi amount was greater than the total bitcoin supply.
647 LDKCreationError_InvalidAmount,
649 * Route hints were required for this invoice and were missing. Applies to
652 [phantom invoices]: crate::utils::create_phantom_invoice
654 LDKCreationError_MissingRouteHints,
656 * The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
658 [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
660 LDKCreationError_MinFinalCltvExpiryDeltaTooShort,
665 * Enum representing the crypto currencies (or networks) supported by this library
667 export enum Currency {
675 LDKCurrency_BitcoinTestnet,
692 * This enum is used to specify which error data to send to peers when failing back an HTLC
693 * using [`ChannelManager::fail_htlc_backwards_with_reason`].
695 * For more info on failure codes, see <https://github.com/lightning/bolts/blob/master/04-onion-routing.md#failure-messages>.
697 export enum FailureCode {
699 * We had a temporary error processing the payment. Useful if no other error codes fit
700 and you want to indicate that the payer may want to retry.
702 LDKFailureCode_TemporaryNodeFailure,
704 * We have a required feature which was not in this onion. For example, you may require
705 some additional metadata that was not provided with this payment.
707 LDKFailureCode_RequiredNodeFeatureMissing,
709 * You may wish to use this when a `payment_preimage` is unknown, or the CLTV expiry of
710 the HTLC is too close to the current block height for safe handling.
711 Using this failure code in [`ChannelManager::fail_htlc_backwards_with_reason`] is
712 equivalent to calling [`ChannelManager::fail_htlc_backwards`].
714 LDKFailureCode_IncorrectOrUnknownPaymentDetails,
719 * Describes the type of HTLC claim as determined by analyzing the witness.
721 export enum HTLCClaim {
723 * Claims an offered output on a commitment transaction through the timeout path.
725 LDKHTLCClaim_OfferedTimeout,
727 * Claims an offered output on a commitment transaction through the success path.
729 LDKHTLCClaim_OfferedPreimage,
731 * Claims an accepted output on a commitment transaction through the timeout path.
733 LDKHTLCClaim_AcceptedTimeout,
735 * Claims an accepted output on a commitment transaction through the success path.
737 LDKHTLCClaim_AcceptedPreimage,
739 * Claims an offered/accepted output on a commitment transaction through the revocation path.
741 LDKHTLCClaim_Revocation,
746 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
748 export enum IOError {
750 LDKIOError_PermissionDenied,
751 LDKIOError_ConnectionRefused,
752 LDKIOError_ConnectionReset,
753 LDKIOError_ConnectionAborted,
754 LDKIOError_NotConnected,
755 LDKIOError_AddrInUse,
756 LDKIOError_AddrNotAvailable,
757 LDKIOError_BrokenPipe,
758 LDKIOError_AlreadyExists,
759 LDKIOError_WouldBlock,
760 LDKIOError_InvalidInput,
761 LDKIOError_InvalidData,
763 LDKIOError_WriteZero,
764 LDKIOError_Interrupted,
766 LDKIOError_UnexpectedEof,
771 * An enum representing the available verbosity levels of the logger.
775 * Designates extremely verbose information, including gossip-induced messages
779 * Designates very low priority, often extremely verbose, information
783 * Designates lower priority information
787 * Designates useful information
791 * Designates hazardous situations
795 * Designates very serious errors
802 * An enum representing the possible Bitcoin or test networks which we can run on
804 export enum Network {
806 * The main Bitcoin blockchain.
810 * The testnet3 blockchain.
814 * A local test blockchain.
818 * A blockchain on which blocks are signed instead of mined.
825 * The reason the payment failed. Used in [`Event::PaymentFailed`].
827 export enum PaymentFailureReason {
829 * The intended recipient rejected our payment.
831 LDKPaymentFailureReason_RecipientRejected,
833 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
835 [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
837 LDKPaymentFailureReason_UserAbandoned,
839 * We exhausted all of our retry attempts while trying to send the payment, or we
840 exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
841 attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
842 have come before this.
844 [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
846 LDKPaymentFailureReason_RetriesExhausted,
848 * The payment expired while retrying, based on the provided
849 [`PaymentParameters::expiry_time`].
851 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
853 LDKPaymentFailureReason_PaymentExpired,
855 * We failed to find a route while retrying the payment.
857 LDKPaymentFailureReason_RouteNotFound,
859 * This error should generally never happen. This likely means that there is a problem with
862 LDKPaymentFailureReason_UnexpectedError,
867 * Specifies the recipient of an invoice.
869 * This indicates to [`NodeSigner::sign_invoice`] what node secret key should be used to sign
872 export enum Recipient {
874 * The invoice should be signed with the local node secret key.
878 * The invoice should be signed with the phantom node secret key. This secret key must be the
879 same for all nodes participating in the [phantom node payment].
881 [phantom node payment]: PhantomKeysManager
883 LDKRecipient_PhantomNode,
888 * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
889 * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
891 * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
892 * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
893 * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
895 export enum RetryableSendFailure {
897 * The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
898 that this error is *not* caused by [`Retry::Timeout`].
900 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
902 LDKRetryableSendFailure_PaymentExpired,
904 * We were unable to find a route to the destination.
906 LDKRetryableSendFailure_RouteNotFound,
908 * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
909 yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
911 [`PaymentId`]: crate::ln::channelmanager::PaymentId
912 [`Event::PaymentSent`]: crate::events::Event::PaymentSent
913 [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
915 LDKRetryableSendFailure_DuplicatePayment,
920 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
922 export enum Secp256k1Error {
924 * Signature failed verification
926 LDKSecp256k1Error_IncorrectSignature,
928 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
930 LDKSecp256k1Error_InvalidMessage,
934 LDKSecp256k1Error_InvalidPublicKey,
938 LDKSecp256k1Error_InvalidSignature,
942 LDKSecp256k1Error_InvalidSecretKey,
946 LDKSecp256k1Error_InvalidSharedSecret,
950 LDKSecp256k1Error_InvalidRecoveryId,
952 * Invalid tweak for add_assign or mul_assign
954 LDKSecp256k1Error_InvalidTweak,
956 * Didn't pass enough memory to context creation with preallocated memory
958 LDKSecp256k1Error_NotEnoughMemory,
960 * Bad set of public keys.
962 LDKSecp256k1Error_InvalidPublicKeySum,
964 * The only valid parity values are 0 or 1.
966 LDKSecp256k1Error_InvalidParityValue,
971 * SI prefixes for the human readable part
973 export enum SiPrefix {
994 * An error when accessing the chain via [`UtxoLookup`].
996 export enum UtxoLookupError {
998 * The requested chain is unknown.
1000 LDKUtxoLookupError_UnknownChain,
1002 * The requested transaction doesn't exist or hasn't confirmed.
1004 LDKUtxoLookupError_UnknownTx,
1007 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
1009 export function BigEndianScalar_get_bytes(thing: bigint): number {
1010 if(!isWasmInitialized) {
1011 throw new Error("initializeWasm() must be awaited first!");
1013 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
1014 return nativeResponseValue;
1016 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
1018 export function BigEndianScalar_free(thing: bigint): void {
1019 if(!isWasmInitialized) {
1020 throw new Error("initializeWasm() must be awaited first!");
1022 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
1023 // debug statements here
1026 export class LDKBech32Error {
1027 protected constructor() {}
1030 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
1031 if(!isWasmInitialized) {
1032 throw new Error("initializeWasm() must be awaited first!");
1034 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
1035 return nativeResponseValue;
1038 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
1039 if(!isWasmInitialized) {
1040 throw new Error("initializeWasm() must be awaited first!");
1042 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
1043 return nativeResponseValue;
1046 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
1047 if(!isWasmInitialized) {
1048 throw new Error("initializeWasm() must be awaited first!");
1050 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
1051 return nativeResponseValue;
1053 // struct LDKWitness TxIn_get_witness (struct LDKTxIn* thing)
1055 export function TxIn_get_witness(thing: bigint): number {
1056 if(!isWasmInitialized) {
1057 throw new Error("initializeWasm() must be awaited first!");
1059 const nativeResponseValue = wasm.TS_TxIn_get_witness(thing);
1060 return nativeResponseValue;
1062 // struct LDKCVec_u8Z TxIn_get_script_sig (struct LDKTxIn* thing)
1064 export function TxIn_get_script_sig(thing: bigint): number {
1065 if(!isWasmInitialized) {
1066 throw new Error("initializeWasm() must be awaited first!");
1068 const nativeResponseValue = wasm.TS_TxIn_get_script_sig(thing);
1069 return nativeResponseValue;
1071 // LDKThirtyTwoBytes TxIn_get_previous_txid (struct LDKTxIn* thing)
1073 export function TxIn_get_previous_txid(thing: bigint): number {
1074 if(!isWasmInitialized) {
1075 throw new Error("initializeWasm() must be awaited first!");
1077 const nativeResponseValue = wasm.TS_TxIn_get_previous_txid(thing);
1078 return nativeResponseValue;
1080 // uint32_t TxIn_get_previous_vout (struct LDKTxIn* thing)
1082 export function TxIn_get_previous_vout(thing: bigint): number {
1083 if(!isWasmInitialized) {
1084 throw new Error("initializeWasm() must be awaited first!");
1086 const nativeResponseValue = wasm.TS_TxIn_get_previous_vout(thing);
1087 return nativeResponseValue;
1089 // uint32_t TxIn_get_sequence (struct LDKTxIn* thing)
1091 export function TxIn_get_sequence(thing: bigint): number {
1092 if(!isWasmInitialized) {
1093 throw new Error("initializeWasm() must be awaited first!");
1095 const nativeResponseValue = wasm.TS_TxIn_get_sequence(thing);
1096 return nativeResponseValue;
1098 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
1100 export function TxOut_get_script_pubkey(thing: bigint): number {
1101 if(!isWasmInitialized) {
1102 throw new Error("initializeWasm() must be awaited first!");
1104 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
1105 return nativeResponseValue;
1107 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
1109 export function TxOut_get_value(thing: bigint): bigint {
1110 if(!isWasmInitialized) {
1111 throw new Error("initializeWasm() must be awaited first!");
1113 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
1114 return nativeResponseValue;
1117 export class LDKCOption_DurationZ {
1118 protected constructor() {}
1121 export function LDKCOption_DurationZ_ty_from_ptr(ptr: bigint): number {
1122 if(!isWasmInitialized) {
1123 throw new Error("initializeWasm() must be awaited first!");
1125 const nativeResponseValue = wasm.TS_LDKCOption_DurationZ_ty_from_ptr(ptr);
1126 return nativeResponseValue;
1129 export function LDKCOption_DurationZ_Some_get_some(ptr: bigint): bigint {
1130 if(!isWasmInitialized) {
1131 throw new Error("initializeWasm() must be awaited first!");
1133 const nativeResponseValue = wasm.TS_LDKCOption_DurationZ_Some_get_some(ptr);
1134 return nativeResponseValue;
1137 export class LDKCOption_u64Z {
1138 protected constructor() {}
1141 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1142 if(!isWasmInitialized) {
1143 throw new Error("initializeWasm() must be awaited first!");
1145 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1146 return nativeResponseValue;
1149 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1150 if(!isWasmInitialized) {
1151 throw new Error("initializeWasm() must be awaited first!");
1153 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1154 return nativeResponseValue;
1156 // struct LDKRefund CResult_RefundBolt12ParseErrorZ_get_ok(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1158 export function CResult_RefundBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
1159 if(!isWasmInitialized) {
1160 throw new Error("initializeWasm() must be awaited first!");
1162 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_ok(owner);
1163 return nativeResponseValue;
1165 // struct LDKBolt12ParseError CResult_RefundBolt12ParseErrorZ_get_err(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1167 export function CResult_RefundBolt12ParseErrorZ_get_err(owner: bigint): bigint {
1168 if(!isWasmInitialized) {
1169 throw new Error("initializeWasm() must be awaited first!");
1171 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_err(owner);
1172 return nativeResponseValue;
1175 export class LDKAPIError {
1176 protected constructor() {}
1179 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
1180 if(!isWasmInitialized) {
1181 throw new Error("initializeWasm() must be awaited first!");
1183 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
1184 return nativeResponseValue;
1187 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
1188 if(!isWasmInitialized) {
1189 throw new Error("initializeWasm() must be awaited first!");
1191 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
1192 return nativeResponseValue;
1195 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
1196 if(!isWasmInitialized) {
1197 throw new Error("initializeWasm() must be awaited first!");
1199 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
1200 return nativeResponseValue;
1203 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
1204 if(!isWasmInitialized) {
1205 throw new Error("initializeWasm() must be awaited first!");
1207 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
1208 return nativeResponseValue;
1211 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
1212 if(!isWasmInitialized) {
1213 throw new Error("initializeWasm() must be awaited first!");
1215 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
1216 return nativeResponseValue;
1219 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
1220 if(!isWasmInitialized) {
1221 throw new Error("initializeWasm() must be awaited first!");
1223 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
1224 return nativeResponseValue;
1227 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
1228 if(!isWasmInitialized) {
1229 throw new Error("initializeWasm() must be awaited first!");
1231 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
1232 return nativeResponseValue;
1234 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1236 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
1237 if(!isWasmInitialized) {
1238 throw new Error("initializeWasm() must be awaited first!");
1240 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
1241 // debug statements here
1243 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1245 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
1246 if(!isWasmInitialized) {
1247 throw new Error("initializeWasm() must be awaited first!");
1249 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
1250 return nativeResponseValue;
1253 export class LDKCOption_PaymentSecretZ {
1254 protected constructor() {}
1257 export function LDKCOption_PaymentSecretZ_ty_from_ptr(ptr: bigint): number {
1258 if(!isWasmInitialized) {
1259 throw new Error("initializeWasm() must be awaited first!");
1261 const nativeResponseValue = wasm.TS_LDKCOption_PaymentSecretZ_ty_from_ptr(ptr);
1262 return nativeResponseValue;
1265 export function LDKCOption_PaymentSecretZ_Some_get_some(ptr: bigint): number {
1266 if(!isWasmInitialized) {
1267 throw new Error("initializeWasm() must be awaited first!");
1269 const nativeResponseValue = wasm.TS_LDKCOption_PaymentSecretZ_Some_get_some(ptr);
1270 return nativeResponseValue;
1273 export class LDKCOption_CVec_u8ZZ {
1274 protected constructor() {}
1277 export function LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr: bigint): number {
1278 if(!isWasmInitialized) {
1279 throw new Error("initializeWasm() must be awaited first!");
1281 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr);
1282 return nativeResponseValue;
1285 export function LDKCOption_CVec_u8ZZ_Some_get_some(ptr: bigint): number {
1286 if(!isWasmInitialized) {
1287 throw new Error("initializeWasm() must be awaited first!");
1289 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_Some_get_some(ptr);
1290 return nativeResponseValue;
1293 export class LDKDecodeError {
1294 protected constructor() {}
1297 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
1298 if(!isWasmInitialized) {
1299 throw new Error("initializeWasm() must be awaited first!");
1301 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
1302 return nativeResponseValue;
1305 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
1306 if(!isWasmInitialized) {
1307 throw new Error("initializeWasm() must be awaited first!");
1309 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
1310 return nativeResponseValue;
1312 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1314 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
1315 if(!isWasmInitialized) {
1316 throw new Error("initializeWasm() must be awaited first!");
1318 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner);
1319 return nativeResponseValue;
1321 // struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1323 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
1324 if(!isWasmInitialized) {
1325 throw new Error("initializeWasm() must be awaited first!");
1327 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner);
1328 return nativeResponseValue;
1331 export class LDKOffersMessage {
1332 protected constructor() {}
1335 export function LDKOffersMessage_ty_from_ptr(ptr: bigint): number {
1336 if(!isWasmInitialized) {
1337 throw new Error("initializeWasm() must be awaited first!");
1339 const nativeResponseValue = wasm.TS_LDKOffersMessage_ty_from_ptr(ptr);
1340 return nativeResponseValue;
1343 export function LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr: bigint): bigint {
1344 if(!isWasmInitialized) {
1345 throw new Error("initializeWasm() must be awaited first!");
1347 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr);
1348 return nativeResponseValue;
1351 export function LDKOffersMessage_Invoice_get_invoice(ptr: bigint): bigint {
1352 if(!isWasmInitialized) {
1353 throw new Error("initializeWasm() must be awaited first!");
1355 const nativeResponseValue = wasm.TS_LDKOffersMessage_Invoice_get_invoice(ptr);
1356 return nativeResponseValue;
1359 export function LDKOffersMessage_InvoiceError_get_invoice_error(ptr: bigint): bigint {
1360 if(!isWasmInitialized) {
1361 throw new Error("initializeWasm() must be awaited first!");
1363 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceError_get_invoice_error(ptr);
1364 return nativeResponseValue;
1367 export class LDKCOption_OffersMessageZ {
1368 protected constructor() {}
1371 export function LDKCOption_OffersMessageZ_ty_from_ptr(ptr: bigint): number {
1372 if(!isWasmInitialized) {
1373 throw new Error("initializeWasm() must be awaited first!");
1375 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_ty_from_ptr(ptr);
1376 return nativeResponseValue;
1379 export function LDKCOption_OffersMessageZ_Some_get_some(ptr: bigint): bigint {
1380 if(!isWasmInitialized) {
1381 throw new Error("initializeWasm() must be awaited first!");
1383 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_Some_get_some(ptr);
1384 return nativeResponseValue;
1386 // struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
1388 export function CResult_OffersMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
1389 if(!isWasmInitialized) {
1390 throw new Error("initializeWasm() must be awaited first!");
1392 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_ok(owner);
1393 return nativeResponseValue;
1395 // struct LDKDecodeError CResult_OffersMessageDecodeErrorZ_get_err(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
1397 export function CResult_OffersMessageDecodeErrorZ_get_err(owner: bigint): bigint {
1398 if(!isWasmInitialized) {
1399 throw new Error("initializeWasm() must be awaited first!");
1401 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_err(owner);
1402 return nativeResponseValue;
1405 export class LDKCOption_HTLCClaimZ {
1406 protected constructor() {}
1409 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
1410 if(!isWasmInitialized) {
1411 throw new Error("initializeWasm() must be awaited first!");
1413 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
1414 return nativeResponseValue;
1417 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
1418 if(!isWasmInitialized) {
1419 throw new Error("initializeWasm() must be awaited first!");
1421 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
1422 return nativeResponseValue;
1424 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1426 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
1427 if(!isWasmInitialized) {
1428 throw new Error("initializeWasm() must be awaited first!");
1430 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
1431 // debug statements here
1433 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1435 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
1436 if(!isWasmInitialized) {
1437 throw new Error("initializeWasm() must be awaited first!");
1439 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
1440 // debug statements here
1442 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
1444 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
1445 if(!isWasmInitialized) {
1446 throw new Error("initializeWasm() must be awaited first!");
1448 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
1449 return nativeResponseValue;
1451 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
1453 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
1454 if(!isWasmInitialized) {
1455 throw new Error("initializeWasm() must be awaited first!");
1457 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
1458 return nativeResponseValue;
1460 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
1462 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
1463 if(!isWasmInitialized) {
1464 throw new Error("initializeWasm() must be awaited first!");
1466 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
1467 return nativeResponseValue;
1469 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
1471 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
1472 if(!isWasmInitialized) {
1473 throw new Error("initializeWasm() must be awaited first!");
1475 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
1476 return nativeResponseValue;
1478 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
1480 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
1481 if(!isWasmInitialized) {
1482 throw new Error("initializeWasm() must be awaited first!");
1484 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
1485 return nativeResponseValue;
1487 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
1489 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
1490 if(!isWasmInitialized) {
1491 throw new Error("initializeWasm() must be awaited first!");
1493 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
1494 return nativeResponseValue;
1497 export class LDKCOption_u32Z {
1498 protected constructor() {}
1501 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
1502 if(!isWasmInitialized) {
1503 throw new Error("initializeWasm() must be awaited first!");
1505 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
1506 return nativeResponseValue;
1509 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
1510 if(!isWasmInitialized) {
1511 throw new Error("initializeWasm() must be awaited first!");
1513 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
1514 return nativeResponseValue;
1516 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
1518 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
1519 if(!isWasmInitialized) {
1520 throw new Error("initializeWasm() must be awaited first!");
1522 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
1523 return nativeResponseValue;
1525 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
1527 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
1528 if(!isWasmInitialized) {
1529 throw new Error("initializeWasm() must be awaited first!");
1531 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
1532 return nativeResponseValue;
1535 export class LDKCOption_PaymentPreimageZ {
1536 protected constructor() {}
1539 export function LDKCOption_PaymentPreimageZ_ty_from_ptr(ptr: bigint): number {
1540 if(!isWasmInitialized) {
1541 throw new Error("initializeWasm() must be awaited first!");
1543 const nativeResponseValue = wasm.TS_LDKCOption_PaymentPreimageZ_ty_from_ptr(ptr);
1544 return nativeResponseValue;
1547 export function LDKCOption_PaymentPreimageZ_Some_get_some(ptr: bigint): number {
1548 if(!isWasmInitialized) {
1549 throw new Error("initializeWasm() must be awaited first!");
1551 const nativeResponseValue = wasm.TS_LDKCOption_PaymentPreimageZ_Some_get_some(ptr);
1552 return nativeResponseValue;
1554 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1556 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1557 if(!isWasmInitialized) {
1558 throw new Error("initializeWasm() must be awaited first!");
1560 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
1561 return nativeResponseValue;
1563 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1565 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1566 if(!isWasmInitialized) {
1567 throw new Error("initializeWasm() must be awaited first!");
1569 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
1570 return nativeResponseValue;
1572 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1574 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1575 if(!isWasmInitialized) {
1576 throw new Error("initializeWasm() must be awaited first!");
1578 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
1579 return nativeResponseValue;
1581 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
1583 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1584 if(!isWasmInitialized) {
1585 throw new Error("initializeWasm() must be awaited first!");
1587 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
1588 return nativeResponseValue;
1590 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1592 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1593 if(!isWasmInitialized) {
1594 throw new Error("initializeWasm() must be awaited first!");
1596 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
1597 return nativeResponseValue;
1599 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1601 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1602 if(!isWasmInitialized) {
1603 throw new Error("initializeWasm() must be awaited first!");
1605 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
1606 return nativeResponseValue;
1608 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1610 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1611 if(!isWasmInitialized) {
1612 throw new Error("initializeWasm() must be awaited first!");
1614 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
1615 return nativeResponseValue;
1617 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1619 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1620 if(!isWasmInitialized) {
1621 throw new Error("initializeWasm() must be awaited first!");
1623 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
1624 return nativeResponseValue;
1626 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1628 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
1629 if(!isWasmInitialized) {
1630 throw new Error("initializeWasm() must be awaited first!");
1632 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
1633 return nativeResponseValue;
1635 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
1637 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
1638 if(!isWasmInitialized) {
1639 throw new Error("initializeWasm() must be awaited first!");
1641 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
1642 // debug statements here
1644 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1646 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
1647 if(!isWasmInitialized) {
1648 throw new Error("initializeWasm() must be awaited first!");
1650 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
1651 return nativeResponseValue;
1653 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
1655 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
1656 if(!isWasmInitialized) {
1657 throw new Error("initializeWasm() must be awaited first!");
1659 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
1660 return nativeResponseValue;
1662 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1664 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
1665 if(!isWasmInitialized) {
1666 throw new Error("initializeWasm() must be awaited first!");
1668 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
1669 return nativeResponseValue;
1671 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
1673 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
1674 if(!isWasmInitialized) {
1675 throw new Error("initializeWasm() must be awaited first!");
1677 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
1678 // debug statements here
1680 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1682 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: bigint): number {
1683 if(!isWasmInitialized) {
1684 throw new Error("initializeWasm() must be awaited first!");
1686 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
1687 return nativeResponseValue;
1689 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1691 export function CResult_CVec_SignatureZNoneZ_get_err(owner: bigint): void {
1692 if(!isWasmInitialized) {
1693 throw new Error("initializeWasm() must be awaited first!");
1695 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1696 // debug statements here
1698 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1700 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
1701 if(!isWasmInitialized) {
1702 throw new Error("initializeWasm() must be awaited first!");
1704 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1705 return nativeResponseValue;
1707 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1709 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
1710 if(!isWasmInitialized) {
1711 throw new Error("initializeWasm() must be awaited first!");
1713 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1714 return nativeResponseValue;
1716 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1718 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
1719 if(!isWasmInitialized) {
1720 throw new Error("initializeWasm() must be awaited first!");
1722 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1723 return nativeResponseValue;
1725 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1727 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
1728 if(!isWasmInitialized) {
1729 throw new Error("initializeWasm() must be awaited first!");
1731 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1732 return nativeResponseValue;
1734 // struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1736 export function CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
1737 if(!isWasmInitialized) {
1738 throw new Error("initializeWasm() must be awaited first!");
1740 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner);
1741 return nativeResponseValue;
1743 // struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1745 export function CResult_BlindedPayInfoDecodeErrorZ_get_err(owner: bigint): bigint {
1746 if(!isWasmInitialized) {
1747 throw new Error("initializeWasm() must be awaited first!");
1749 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(owner);
1750 return nativeResponseValue;
1752 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1754 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1755 if(!isWasmInitialized) {
1756 throw new Error("initializeWasm() must be awaited first!");
1758 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1759 return nativeResponseValue;
1761 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1763 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1764 if(!isWasmInitialized) {
1765 throw new Error("initializeWasm() must be awaited first!");
1767 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1768 return nativeResponseValue;
1770 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1772 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1773 if(!isWasmInitialized) {
1774 throw new Error("initializeWasm() must be awaited first!");
1776 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1777 return nativeResponseValue;
1779 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1781 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1782 if(!isWasmInitialized) {
1783 throw new Error("initializeWasm() must be awaited first!");
1785 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1786 return nativeResponseValue;
1789 export class LDKSpendableOutputDescriptor {
1790 protected constructor() {}
1793 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1794 if(!isWasmInitialized) {
1795 throw new Error("initializeWasm() must be awaited first!");
1797 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1798 return nativeResponseValue;
1801 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1802 if(!isWasmInitialized) {
1803 throw new Error("initializeWasm() must be awaited first!");
1805 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1806 return nativeResponseValue;
1809 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1810 if(!isWasmInitialized) {
1811 throw new Error("initializeWasm() must be awaited first!");
1813 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1814 return nativeResponseValue;
1817 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1818 if(!isWasmInitialized) {
1819 throw new Error("initializeWasm() must be awaited first!");
1821 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1822 return nativeResponseValue;
1825 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1826 if(!isWasmInitialized) {
1827 throw new Error("initializeWasm() must be awaited first!");
1829 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1830 return nativeResponseValue;
1832 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1834 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1835 if(!isWasmInitialized) {
1836 throw new Error("initializeWasm() must be awaited first!");
1838 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
1839 return nativeResponseValue;
1841 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1843 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1844 if(!isWasmInitialized) {
1845 throw new Error("initializeWasm() must be awaited first!");
1847 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
1848 return nativeResponseValue;
1851 export class LDKCOption_PackedLockTimeZ {
1852 protected constructor() {}
1855 export function LDKCOption_PackedLockTimeZ_ty_from_ptr(ptr: bigint): number {
1856 if(!isWasmInitialized) {
1857 throw new Error("initializeWasm() must be awaited first!");
1859 const nativeResponseValue = wasm.TS_LDKCOption_PackedLockTimeZ_ty_from_ptr(ptr);
1860 return nativeResponseValue;
1863 export function LDKCOption_PackedLockTimeZ_Some_get_some(ptr: bigint): number {
1864 if(!isWasmInitialized) {
1865 throw new Error("initializeWasm() must be awaited first!");
1867 const nativeResponseValue = wasm.TS_LDKCOption_PackedLockTimeZ_Some_get_some(ptr);
1868 return nativeResponseValue;
1870 // struct LDKCVec_u8Z C2Tuple_PartiallySignedTransactionusizeZ_get_a(LDKC2Tuple_PartiallySignedTransactionusizeZ *NONNULL_PTR owner);
1872 export function C2Tuple_PartiallySignedTransactionusizeZ_get_a(owner: bigint): number {
1873 if(!isWasmInitialized) {
1874 throw new Error("initializeWasm() must be awaited first!");
1876 const nativeResponseValue = wasm.TS_C2Tuple_PartiallySignedTransactionusizeZ_get_a(owner);
1877 return nativeResponseValue;
1879 // uintptr_t C2Tuple_PartiallySignedTransactionusizeZ_get_b(LDKC2Tuple_PartiallySignedTransactionusizeZ *NONNULL_PTR owner);
1881 export function C2Tuple_PartiallySignedTransactionusizeZ_get_b(owner: bigint): number {
1882 if(!isWasmInitialized) {
1883 throw new Error("initializeWasm() must be awaited first!");
1885 const nativeResponseValue = wasm.TS_C2Tuple_PartiallySignedTransactionusizeZ_get_b(owner);
1886 return nativeResponseValue;
1888 // struct LDKC2Tuple_PartiallySignedTransactionusizeZ CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_get_ok(LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ *NONNULL_PTR owner);
1890 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_get_ok(owner: bigint): bigint {
1891 if(!isWasmInitialized) {
1892 throw new Error("initializeWasm() must be awaited first!");
1894 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_get_ok(owner);
1895 return nativeResponseValue;
1897 // void CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_get_err(LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ *NONNULL_PTR owner);
1899 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_get_err(owner: bigint): void {
1900 if(!isWasmInitialized) {
1901 throw new Error("initializeWasm() must be awaited first!");
1903 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_get_err(owner);
1904 // debug statements here
1906 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
1908 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: bigint): number {
1909 if(!isWasmInitialized) {
1910 throw new Error("initializeWasm() must be awaited first!");
1912 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
1913 return nativeResponseValue;
1915 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
1917 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: bigint): number {
1918 if(!isWasmInitialized) {
1919 throw new Error("initializeWasm() must be awaited first!");
1921 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
1922 return nativeResponseValue;
1924 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
1926 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: bigint): bigint {
1927 if(!isWasmInitialized) {
1928 throw new Error("initializeWasm() must be awaited first!");
1930 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
1931 return nativeResponseValue;
1933 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
1935 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: bigint): void {
1936 if(!isWasmInitialized) {
1937 throw new Error("initializeWasm() must be awaited first!");
1939 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
1940 // debug statements here
1942 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
1944 export function CResult_SignatureNoneZ_get_ok(owner: bigint): number {
1945 if(!isWasmInitialized) {
1946 throw new Error("initializeWasm() must be awaited first!");
1948 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
1949 return nativeResponseValue;
1951 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
1953 export function CResult_SignatureNoneZ_get_err(owner: bigint): void {
1954 if(!isWasmInitialized) {
1955 throw new Error("initializeWasm() must be awaited first!");
1957 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
1958 // debug statements here
1960 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1962 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
1963 if(!isWasmInitialized) {
1964 throw new Error("initializeWasm() must be awaited first!");
1966 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
1967 return nativeResponseValue;
1969 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1971 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
1972 if(!isWasmInitialized) {
1973 throw new Error("initializeWasm() must be awaited first!");
1975 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
1976 // debug statements here
1979 export class LDKCOption_ScalarZ {
1980 protected constructor() {}
1983 export function LDKCOption_ScalarZ_ty_from_ptr(ptr: bigint): number {
1984 if(!isWasmInitialized) {
1985 throw new Error("initializeWasm() must be awaited first!");
1987 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_ty_from_ptr(ptr);
1988 return nativeResponseValue;
1991 export function LDKCOption_ScalarZ_Some_get_some(ptr: bigint): bigint {
1992 if(!isWasmInitialized) {
1993 throw new Error("initializeWasm() must be awaited first!");
1995 const nativeResponseValue = wasm.TS_LDKCOption_ScalarZ_Some_get_some(ptr);
1996 return nativeResponseValue;
1998 // struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
2000 export function CResult_SharedSecretNoneZ_get_ok(owner: bigint): number {
2001 if(!isWasmInitialized) {
2002 throw new Error("initializeWasm() must be awaited first!");
2004 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_ok(owner);
2005 return nativeResponseValue;
2007 // void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner);
2009 export function CResult_SharedSecretNoneZ_get_err(owner: bigint): void {
2010 if(!isWasmInitialized) {
2011 throw new Error("initializeWasm() must be awaited first!");
2013 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_get_err(owner);
2014 // debug statements here
2016 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2018 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
2019 if(!isWasmInitialized) {
2020 throw new Error("initializeWasm() must be awaited first!");
2022 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
2023 return nativeResponseValue;
2025 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2027 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
2028 if(!isWasmInitialized) {
2029 throw new Error("initializeWasm() must be awaited first!");
2031 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
2032 // debug statements here
2035 export interface LDKChannelSigner {
2036 get_per_commitment_point (idx: bigint): number;
2037 release_commitment_secret (idx: bigint): number;
2038 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
2039 channel_keys_id (): number;
2040 provide_channel_parameters (channel_parameters: bigint): void;
2044 export function LDKChannelSigner_new(impl: LDKChannelSigner, pubkeys: bigint): [bigint, number] {
2045 if(!isWasmInitialized) {
2046 throw new Error("initializeWasm() must be awaited first!");
2048 var new_obj_idx = js_objs.length;
2049 for (var i = 0; i < js_objs.length; i++) {
2050 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2052 js_objs[i] = new WeakRef(impl);
2053 return [wasm.TS_LDKChannelSigner_new(i, pubkeys), i];
2055 // LDKPublicKey ChannelSigner_get_per_commitment_point LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
2057 export function ChannelSigner_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
2058 if(!isWasmInitialized) {
2059 throw new Error("initializeWasm() must be awaited first!");
2061 const nativeResponseValue = wasm.TS_ChannelSigner_get_per_commitment_point(this_arg, idx);
2062 return nativeResponseValue;
2064 // LDKThirtyTwoBytes ChannelSigner_release_commitment_secret LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
2066 export function ChannelSigner_release_commitment_secret(this_arg: bigint, idx: bigint): number {
2067 if(!isWasmInitialized) {
2068 throw new Error("initializeWasm() must be awaited first!");
2070 const nativeResponseValue = wasm.TS_ChannelSigner_release_commitment_secret(this_arg, idx);
2071 return nativeResponseValue;
2073 // LDKCResult_NoneNoneZ ChannelSigner_validate_holder_commitment LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
2075 export function ChannelSigner_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
2076 if(!isWasmInitialized) {
2077 throw new Error("initializeWasm() must be awaited first!");
2079 const nativeResponseValue = wasm.TS_ChannelSigner_validate_holder_commitment(this_arg, holder_tx, preimages);
2080 return nativeResponseValue;
2082 // LDKThirtyTwoBytes ChannelSigner_channel_keys_id LDKChannelSigner *NONNULL_PTR this_arg
2084 export function ChannelSigner_channel_keys_id(this_arg: bigint): number {
2085 if(!isWasmInitialized) {
2086 throw new Error("initializeWasm() must be awaited first!");
2088 const nativeResponseValue = wasm.TS_ChannelSigner_channel_keys_id(this_arg);
2089 return nativeResponseValue;
2091 // void ChannelSigner_provide_channel_parameters LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
2093 export function ChannelSigner_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
2094 if(!isWasmInitialized) {
2095 throw new Error("initializeWasm() must be awaited first!");
2097 const nativeResponseValue = wasm.TS_ChannelSigner_provide_channel_parameters(this_arg, channel_parameters);
2098 // debug statements here
2100 // LDKChannelPublicKeys ChannelSigner_get_pubkeys LDKChannelSigner *NONNULL_PTR this_arg
2102 export function ChannelSigner_get_pubkeys(this_arg: bigint): bigint {
2103 if(!isWasmInitialized) {
2104 throw new Error("initializeWasm() must be awaited first!");
2106 const nativeResponseValue = wasm.TS_ChannelSigner_get_pubkeys(this_arg);
2107 return nativeResponseValue;
2110 export interface LDKEcdsaChannelSigner {
2111 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
2112 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
2113 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
2114 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
2115 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
2116 sign_holder_htlc_transaction (htlc_tx: number, input: number, htlc_descriptor: bigint): bigint;
2117 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
2118 sign_closing_transaction (closing_tx: bigint): bigint;
2119 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
2120 sign_channel_announcement_with_funding_key (msg: bigint): bigint;
2124 export function LDKEcdsaChannelSigner_new(impl: LDKEcdsaChannelSigner, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
2125 if(!isWasmInitialized) {
2126 throw new Error("initializeWasm() must be awaited first!");
2128 var new_obj_idx = js_objs.length;
2129 for (var i = 0; i < js_objs.length; i++) {
2130 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2132 js_objs[i] = new WeakRef(impl);
2133 return [wasm.TS_LDKEcdsaChannelSigner_new(i, ChannelSigner, pubkeys), i];
2135 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ EcdsaChannelSigner_sign_counterparty_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
2137 export function EcdsaChannelSigner_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
2138 if(!isWasmInitialized) {
2139 throw new Error("initializeWasm() must be awaited first!");
2141 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
2142 return nativeResponseValue;
2144 // LDKCResult_NoneNoneZ EcdsaChannelSigner_validate_counterparty_revocation LDKEcdsaChannelSigner *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
2146 export function EcdsaChannelSigner_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
2147 if(!isWasmInitialized) {
2148 throw new Error("initializeWasm() must be awaited first!");
2150 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_validate_counterparty_revocation(this_arg, idx, secret);
2151 return nativeResponseValue;
2153 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ EcdsaChannelSigner_sign_holder_commitment_and_htlcs LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
2155 export function EcdsaChannelSigner_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
2156 if(!isWasmInitialized) {
2157 throw new Error("initializeWasm() must be awaited first!");
2159 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
2160 return nativeResponseValue;
2162 // 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]
2164 export function EcdsaChannelSigner_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
2165 if(!isWasmInitialized) {
2166 throw new Error("initializeWasm() must be awaited first!");
2168 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
2169 return nativeResponseValue;
2171 // 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
2173 export function EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
2174 if(!isWasmInitialized) {
2175 throw new Error("initializeWasm() must be awaited first!");
2177 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
2178 return nativeResponseValue;
2180 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_holder_htlc_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor
2182 export function EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, htlc_descriptor: bigint): bigint {
2183 if(!isWasmInitialized) {
2184 throw new Error("initializeWasm() must be awaited first!");
2186 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg, htlc_tx, input, htlc_descriptor);
2187 return nativeResponseValue;
2189 // 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
2191 export function EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
2192 if(!isWasmInitialized) {
2193 throw new Error("initializeWasm() must be awaited first!");
2195 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
2196 return nativeResponseValue;
2198 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_closing_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
2200 export function EcdsaChannelSigner_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
2201 if(!isWasmInitialized) {
2202 throw new Error("initializeWasm() must be awaited first!");
2204 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_closing_transaction(this_arg, closing_tx);
2205 return nativeResponseValue;
2207 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_holder_anchor_input LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
2209 export function EcdsaChannelSigner_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
2210 if(!isWasmInitialized) {
2211 throw new Error("initializeWasm() must be awaited first!");
2213 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_anchor_input(this_arg, anchor_tx, input);
2214 return nativeResponseValue;
2216 // LDKCResult_SignatureNoneZ EcdsaChannelSigner_sign_channel_announcement_with_funding_key LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
2218 export function EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg: bigint, msg: bigint): bigint {
2219 if(!isWasmInitialized) {
2220 throw new Error("initializeWasm() must be awaited first!");
2222 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg, msg);
2223 return nativeResponseValue;
2226 export interface LDKWriteableEcdsaChannelSigner {
2231 export function LDKWriteableEcdsaChannelSigner_new(impl: LDKWriteableEcdsaChannelSigner, EcdsaChannelSigner: number, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
2232 if(!isWasmInitialized) {
2233 throw new Error("initializeWasm() must be awaited first!");
2235 var new_obj_idx = js_objs.length;
2236 for (var i = 0; i < js_objs.length; i++) {
2237 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2239 js_objs[i] = new WeakRef(impl);
2240 return [wasm.TS_LDKWriteableEcdsaChannelSigner_new(i, EcdsaChannelSigner, ChannelSigner, pubkeys), i];
2242 // LDKCVec_u8Z WriteableEcdsaChannelSigner_write LDKWriteableEcdsaChannelSigner *NONNULL_PTR this_arg
2244 export function WriteableEcdsaChannelSigner_write(this_arg: bigint): number {
2245 if(!isWasmInitialized) {
2246 throw new Error("initializeWasm() must be awaited first!");
2248 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_write(this_arg);
2249 return nativeResponseValue;
2251 // struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2253 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2254 if(!isWasmInitialized) {
2255 throw new Error("initializeWasm() must be awaited first!");
2257 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner);
2258 return nativeResponseValue;
2260 // struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2262 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner: bigint): bigint {
2263 if(!isWasmInitialized) {
2264 throw new Error("initializeWasm() must be awaited first!");
2266 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner);
2267 return nativeResponseValue;
2269 // struct LDKCVec_u8Z CResult_ScriptNoneZ_get_ok(LDKCResult_ScriptNoneZ *NONNULL_PTR owner);
2271 export function CResult_ScriptNoneZ_get_ok(owner: bigint): number {
2272 if(!isWasmInitialized) {
2273 throw new Error("initializeWasm() must be awaited first!");
2275 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_get_ok(owner);
2276 return nativeResponseValue;
2278 // void CResult_ScriptNoneZ_get_err(LDKCResult_ScriptNoneZ *NONNULL_PTR owner);
2280 export function CResult_ScriptNoneZ_get_err(owner: bigint): void {
2281 if(!isWasmInitialized) {
2282 throw new Error("initializeWasm() must be awaited first!");
2284 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_get_err(owner);
2285 // debug statements here
2287 // struct LDKShutdownScript CResult_ShutdownScriptNoneZ_get_ok(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2289 export function CResult_ShutdownScriptNoneZ_get_ok(owner: bigint): bigint {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_ok(owner);
2294 return nativeResponseValue;
2296 // void CResult_ShutdownScriptNoneZ_get_err(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2298 export function CResult_ShutdownScriptNoneZ_get_err(owner: bigint): void {
2299 if(!isWasmInitialized) {
2300 throw new Error("initializeWasm() must be awaited first!");
2302 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_err(owner);
2303 // debug statements here
2305 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2307 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
2308 if(!isWasmInitialized) {
2309 throw new Error("initializeWasm() must be awaited first!");
2311 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
2312 return nativeResponseValue;
2314 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2316 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
2321 // debug statements here
2323 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2325 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2326 if(!isWasmInitialized) {
2327 throw new Error("initializeWasm() must be awaited first!");
2329 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2330 return nativeResponseValue;
2332 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2334 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
2335 if(!isWasmInitialized) {
2336 throw new Error("initializeWasm() must be awaited first!");
2338 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2339 return nativeResponseValue;
2341 // struct LDKCVec_u8Z CResult_PartiallySignedTransactionNoneZ_get_ok(LDKCResult_PartiallySignedTransactionNoneZ *NONNULL_PTR owner);
2343 export function CResult_PartiallySignedTransactionNoneZ_get_ok(owner: bigint): number {
2344 if(!isWasmInitialized) {
2345 throw new Error("initializeWasm() must be awaited first!");
2347 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_get_ok(owner);
2348 return nativeResponseValue;
2350 // void CResult_PartiallySignedTransactionNoneZ_get_err(LDKCResult_PartiallySignedTransactionNoneZ *NONNULL_PTR owner);
2352 export function CResult_PartiallySignedTransactionNoneZ_get_err(owner: bigint): void {
2353 if(!isWasmInitialized) {
2354 throw new Error("initializeWasm() must be awaited first!");
2356 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_get_err(owner);
2357 // debug statements here
2359 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2361 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
2362 if(!isWasmInitialized) {
2363 throw new Error("initializeWasm() must be awaited first!");
2365 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2366 return nativeResponseValue;
2368 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2370 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
2371 if(!isWasmInitialized) {
2372 throw new Error("initializeWasm() must be awaited first!");
2374 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2375 // debug statements here
2377 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2379 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
2380 if(!isWasmInitialized) {
2381 throw new Error("initializeWasm() must be awaited first!");
2383 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2384 return nativeResponseValue;
2386 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2388 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
2389 if(!isWasmInitialized) {
2390 throw new Error("initializeWasm() must be awaited first!");
2392 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2393 return nativeResponseValue;
2395 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2397 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
2398 if(!isWasmInitialized) {
2399 throw new Error("initializeWasm() must be awaited first!");
2401 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
2402 return nativeResponseValue;
2404 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2406 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
2407 if(!isWasmInitialized) {
2408 throw new Error("initializeWasm() must be awaited first!");
2410 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
2411 return nativeResponseValue;
2413 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2415 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2416 if(!isWasmInitialized) {
2417 throw new Error("initializeWasm() must be awaited first!");
2419 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
2420 return nativeResponseValue;
2422 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2424 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
2425 if(!isWasmInitialized) {
2426 throw new Error("initializeWasm() must be awaited first!");
2428 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
2429 return nativeResponseValue;
2431 // struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2433 export function CResult_BlindedTailDecodeErrorZ_get_ok(owner: bigint): bigint {
2434 if(!isWasmInitialized) {
2435 throw new Error("initializeWasm() must be awaited first!");
2437 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_ok(owner);
2438 return nativeResponseValue;
2440 // struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2442 export function CResult_BlindedTailDecodeErrorZ_get_err(owner: bigint): bigint {
2443 if(!isWasmInitialized) {
2444 throw new Error("initializeWasm() must be awaited first!");
2446 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_err(owner);
2447 return nativeResponseValue;
2449 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2451 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
2452 if(!isWasmInitialized) {
2453 throw new Error("initializeWasm() must be awaited first!");
2455 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
2456 return nativeResponseValue;
2458 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2460 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
2461 if(!isWasmInitialized) {
2462 throw new Error("initializeWasm() must be awaited first!");
2464 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
2465 return nativeResponseValue;
2467 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2469 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2470 if(!isWasmInitialized) {
2471 throw new Error("initializeWasm() must be awaited first!");
2473 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
2474 return nativeResponseValue;
2476 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2478 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2479 if(!isWasmInitialized) {
2480 throw new Error("initializeWasm() must be awaited first!");
2482 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
2483 return nativeResponseValue;
2485 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2487 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2488 if(!isWasmInitialized) {
2489 throw new Error("initializeWasm() must be awaited first!");
2491 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
2492 return nativeResponseValue;
2494 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2496 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2497 if(!isWasmInitialized) {
2498 throw new Error("initializeWasm() must be awaited first!");
2500 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
2501 return nativeResponseValue;
2503 // struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2505 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner: bigint): bigint {
2506 if(!isWasmInitialized) {
2507 throw new Error("initializeWasm() must be awaited first!");
2509 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner);
2510 return nativeResponseValue;
2512 // struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2514 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner: bigint): bigint {
2515 if(!isWasmInitialized) {
2516 throw new Error("initializeWasm() must be awaited first!");
2518 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner);
2519 return nativeResponseValue;
2521 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2523 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
2524 if(!isWasmInitialized) {
2525 throw new Error("initializeWasm() must be awaited first!");
2527 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2528 return nativeResponseValue;
2530 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2532 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
2533 if(!isWasmInitialized) {
2534 throw new Error("initializeWasm() must be awaited first!");
2536 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2537 return nativeResponseValue;
2539 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2541 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2542 if(!isWasmInitialized) {
2543 throw new Error("initializeWasm() must be awaited first!");
2545 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2546 return nativeResponseValue;
2548 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2550 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
2551 if(!isWasmInitialized) {
2552 throw new Error("initializeWasm() must be awaited first!");
2554 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2555 return nativeResponseValue;
2557 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2559 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2560 if(!isWasmInitialized) {
2561 throw new Error("initializeWasm() must be awaited first!");
2563 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2564 return nativeResponseValue;
2566 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2568 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2569 if(!isWasmInitialized) {
2570 throw new Error("initializeWasm() must be awaited first!");
2572 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2573 return nativeResponseValue;
2576 export class LDKCOption_BlockHashZ {
2577 protected constructor() {}
2580 export function LDKCOption_BlockHashZ_ty_from_ptr(ptr: bigint): number {
2581 if(!isWasmInitialized) {
2582 throw new Error("initializeWasm() must be awaited first!");
2584 const nativeResponseValue = wasm.TS_LDKCOption_BlockHashZ_ty_from_ptr(ptr);
2585 return nativeResponseValue;
2588 export function LDKCOption_BlockHashZ_Some_get_some(ptr: bigint): number {
2589 if(!isWasmInitialized) {
2590 throw new Error("initializeWasm() must be awaited first!");
2592 const nativeResponseValue = wasm.TS_LDKCOption_BlockHashZ_Some_get_some(ptr);
2593 return nativeResponseValue;
2595 // struct LDKThirtyTwoBytes C2Tuple_TxidCOption_BlockHashZZ_get_a(LDKC2Tuple_TxidCOption_BlockHashZZ *NONNULL_PTR owner);
2597 export function C2Tuple_TxidCOption_BlockHashZZ_get_a(owner: bigint): number {
2598 if(!isWasmInitialized) {
2599 throw new Error("initializeWasm() must be awaited first!");
2601 const nativeResponseValue = wasm.TS_C2Tuple_TxidCOption_BlockHashZZ_get_a(owner);
2602 return nativeResponseValue;
2604 // struct LDKCOption_BlockHashZ C2Tuple_TxidCOption_BlockHashZZ_get_b(LDKC2Tuple_TxidCOption_BlockHashZZ *NONNULL_PTR owner);
2606 export function C2Tuple_TxidCOption_BlockHashZZ_get_b(owner: bigint): bigint {
2607 if(!isWasmInitialized) {
2608 throw new Error("initializeWasm() must be awaited first!");
2610 const nativeResponseValue = wasm.TS_C2Tuple_TxidCOption_BlockHashZZ_get_b(owner);
2611 return nativeResponseValue;
2614 export class LDKMonitorEvent {
2615 protected constructor() {}
2618 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2619 if(!isWasmInitialized) {
2620 throw new Error("initializeWasm() must be awaited first!");
2622 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2623 return nativeResponseValue;
2626 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2627 if(!isWasmInitialized) {
2628 throw new Error("initializeWasm() must be awaited first!");
2630 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2631 return nativeResponseValue;
2634 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
2635 if(!isWasmInitialized) {
2636 throw new Error("initializeWasm() must be awaited first!");
2638 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2639 return nativeResponseValue;
2642 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2643 if(!isWasmInitialized) {
2644 throw new Error("initializeWasm() must be awaited first!");
2646 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2647 return nativeResponseValue;
2650 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2651 if(!isWasmInitialized) {
2652 throw new Error("initializeWasm() must be awaited first!");
2654 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2655 return nativeResponseValue;
2658 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
2659 if(!isWasmInitialized) {
2660 throw new Error("initializeWasm() must be awaited first!");
2662 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2663 return nativeResponseValue;
2665 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2667 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2668 if(!isWasmInitialized) {
2669 throw new Error("initializeWasm() must be awaited first!");
2671 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2672 return nativeResponseValue;
2674 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2676 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2677 if(!isWasmInitialized) {
2678 throw new Error("initializeWasm() must be awaited first!");
2680 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2681 return nativeResponseValue;
2683 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2685 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2686 if(!isWasmInitialized) {
2687 throw new Error("initializeWasm() must be awaited first!");
2689 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2690 return nativeResponseValue;
2692 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2694 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2695 if(!isWasmInitialized) {
2696 throw new Error("initializeWasm() must be awaited first!");
2698 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2699 return nativeResponseValue;
2701 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2703 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2704 if(!isWasmInitialized) {
2705 throw new Error("initializeWasm() must be awaited first!");
2707 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2708 return nativeResponseValue;
2710 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2712 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2713 if(!isWasmInitialized) {
2714 throw new Error("initializeWasm() must be awaited first!");
2716 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2717 return nativeResponseValue;
2719 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2721 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2722 if(!isWasmInitialized) {
2723 throw new Error("initializeWasm() must be awaited first!");
2725 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2726 return nativeResponseValue;
2729 export class LDKCOption_C2Tuple_u64u64ZZ {
2730 protected constructor() {}
2733 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2734 if(!isWasmInitialized) {
2735 throw new Error("initializeWasm() must be awaited first!");
2737 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2738 return nativeResponseValue;
2741 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2742 if(!isWasmInitialized) {
2743 throw new Error("initializeWasm() must be awaited first!");
2745 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2746 return nativeResponseValue;
2748 // struct LDKEightU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
2750 export function C2Tuple_Z_get_a(owner: bigint): number {
2751 if(!isWasmInitialized) {
2752 throw new Error("initializeWasm() must be awaited first!");
2754 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
2755 return nativeResponseValue;
2757 // struct LDKEightU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
2759 export function C2Tuple_Z_get_b(owner: bigint): number {
2760 if(!isWasmInitialized) {
2761 throw new Error("initializeWasm() must be awaited first!");
2763 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
2764 return nativeResponseValue;
2766 // struct LDKEightU16s C2Tuple__u168_u168Z_get_a(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
2768 export function C2Tuple__u168_u168Z_get_a(owner: bigint): number {
2769 if(!isWasmInitialized) {
2770 throw new Error("initializeWasm() must be awaited first!");
2772 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_a(owner);
2773 return nativeResponseValue;
2775 // struct LDKEightU16s C2Tuple__u168_u168Z_get_b(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner);
2777 export function C2Tuple__u168_u168Z_get_b(owner: bigint): number {
2778 if(!isWasmInitialized) {
2779 throw new Error("initializeWasm() must be awaited first!");
2781 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_get_b(owner);
2782 return nativeResponseValue;
2785 export class LDKCOption_C2Tuple_EightU16sEightU16sZZ {
2786 protected constructor() {}
2789 export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr: bigint): number {
2790 if(!isWasmInitialized) {
2791 throw new Error("initializeWasm() must be awaited first!");
2793 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(ptr);
2794 return nativeResponseValue;
2797 export function LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr: bigint): bigint {
2798 if(!isWasmInitialized) {
2799 throw new Error("initializeWasm() must be awaited first!");
2801 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(ptr);
2802 return nativeResponseValue;
2805 export interface LDKLogger {
2806 log (record: bigint): void;
2810 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2811 if(!isWasmInitialized) {
2812 throw new Error("initializeWasm() must be awaited first!");
2814 var new_obj_idx = js_objs.length;
2815 for (var i = 0; i < js_objs.length; i++) {
2816 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2818 js_objs[i] = new WeakRef(impl);
2819 return [wasm.TS_LDKLogger_new(i), i];
2821 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2823 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2824 if(!isWasmInitialized) {
2825 throw new Error("initializeWasm() must be awaited first!");
2827 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2828 return nativeResponseValue;
2830 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2832 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2833 if(!isWasmInitialized) {
2834 throw new Error("initializeWasm() must be awaited first!");
2836 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2837 return nativeResponseValue;
2839 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2841 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2842 if(!isWasmInitialized) {
2843 throw new Error("initializeWasm() must be awaited first!");
2845 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2846 return nativeResponseValue;
2848 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2850 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2851 if(!isWasmInitialized) {
2852 throw new Error("initializeWasm() must be awaited first!");
2854 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2855 return nativeResponseValue;
2857 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2859 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2860 if(!isWasmInitialized) {
2861 throw new Error("initializeWasm() must be awaited first!");
2863 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2864 return nativeResponseValue;
2866 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2868 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2869 if(!isWasmInitialized) {
2870 throw new Error("initializeWasm() must be awaited first!");
2872 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2873 return nativeResponseValue;
2875 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2877 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2878 if(!isWasmInitialized) {
2879 throw new Error("initializeWasm() must be awaited first!");
2881 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2882 return nativeResponseValue;
2884 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2886 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2887 if(!isWasmInitialized) {
2888 throw new Error("initializeWasm() must be awaited first!");
2890 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2891 return nativeResponseValue;
2893 // struct LDKBolt11InvoiceFeatures CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2895 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2896 if(!isWasmInitialized) {
2897 throw new Error("initializeWasm() must be awaited first!");
2899 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2900 return nativeResponseValue;
2902 // struct LDKDecodeError CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2904 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2905 if(!isWasmInitialized) {
2906 throw new Error("initializeWasm() must be awaited first!");
2908 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner);
2909 return nativeResponseValue;
2911 // struct LDKBolt12InvoiceFeatures CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2913 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2914 if(!isWasmInitialized) {
2915 throw new Error("initializeWasm() must be awaited first!");
2917 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2918 return nativeResponseValue;
2920 // struct LDKDecodeError CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2922 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2923 if(!isWasmInitialized) {
2924 throw new Error("initializeWasm() must be awaited first!");
2926 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner);
2927 return nativeResponseValue;
2929 // struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2931 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2932 if(!isWasmInitialized) {
2933 throw new Error("initializeWasm() must be awaited first!");
2935 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
2936 return nativeResponseValue;
2938 // struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2940 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2941 if(!isWasmInitialized) {
2942 throw new Error("initializeWasm() must be awaited first!");
2944 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
2945 return nativeResponseValue;
2947 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2949 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2950 if(!isWasmInitialized) {
2951 throw new Error("initializeWasm() must be awaited first!");
2953 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2954 return nativeResponseValue;
2956 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2958 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2959 if(!isWasmInitialized) {
2960 throw new Error("initializeWasm() must be awaited first!");
2962 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2963 return nativeResponseValue;
2966 export class LDKPaymentPurpose {
2967 protected constructor() {}
2970 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
2971 if(!isWasmInitialized) {
2972 throw new Error("initializeWasm() must be awaited first!");
2974 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
2975 return nativeResponseValue;
2978 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): bigint {
2979 if(!isWasmInitialized) {
2980 throw new Error("initializeWasm() must be awaited first!");
2982 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
2983 return nativeResponseValue;
2986 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
2987 if(!isWasmInitialized) {
2988 throw new Error("initializeWasm() must be awaited first!");
2990 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
2991 return nativeResponseValue;
2994 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
2995 if(!isWasmInitialized) {
2996 throw new Error("initializeWasm() must be awaited first!");
2998 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
2999 return nativeResponseValue;
3001 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
3003 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
3004 if(!isWasmInitialized) {
3005 throw new Error("initializeWasm() must be awaited first!");
3007 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
3008 return nativeResponseValue;
3010 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
3012 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
3013 if(!isWasmInitialized) {
3014 throw new Error("initializeWasm() must be awaited first!");
3016 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
3017 return nativeResponseValue;
3020 export class LDKNetworkUpdate {
3021 protected constructor() {}
3024 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
3025 if(!isWasmInitialized) {
3026 throw new Error("initializeWasm() must be awaited first!");
3028 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
3029 return nativeResponseValue;
3032 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
3033 if(!isWasmInitialized) {
3034 throw new Error("initializeWasm() must be awaited first!");
3036 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
3037 return nativeResponseValue;
3040 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
3041 if(!isWasmInitialized) {
3042 throw new Error("initializeWasm() must be awaited first!");
3044 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
3045 return nativeResponseValue;
3048 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
3049 if(!isWasmInitialized) {
3050 throw new Error("initializeWasm() must be awaited first!");
3052 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
3053 return nativeResponseValue;
3056 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
3057 if(!isWasmInitialized) {
3058 throw new Error("initializeWasm() must be awaited first!");
3060 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
3061 return nativeResponseValue;
3064 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
3065 if(!isWasmInitialized) {
3066 throw new Error("initializeWasm() must be awaited first!");
3068 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
3069 return nativeResponseValue;
3072 export class LDKCOption_NetworkUpdateZ {
3073 protected constructor() {}
3076 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
3077 if(!isWasmInitialized) {
3078 throw new Error("initializeWasm() must be awaited first!");
3080 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
3081 return nativeResponseValue;
3084 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
3085 if(!isWasmInitialized) {
3086 throw new Error("initializeWasm() must be awaited first!");
3088 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
3089 return nativeResponseValue;
3092 export class LDKPathFailure {
3093 protected constructor() {}
3096 export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
3097 if(!isWasmInitialized) {
3098 throw new Error("initializeWasm() must be awaited first!");
3100 const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
3101 return nativeResponseValue;
3104 export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
3105 if(!isWasmInitialized) {
3106 throw new Error("initializeWasm() must be awaited first!");
3108 const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
3109 return nativeResponseValue;
3112 export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
3113 if(!isWasmInitialized) {
3114 throw new Error("initializeWasm() must be awaited first!");
3116 const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
3117 return nativeResponseValue;
3120 export class LDKCOption_PathFailureZ {
3121 protected constructor() {}
3124 export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
3125 if(!isWasmInitialized) {
3126 throw new Error("initializeWasm() must be awaited first!");
3128 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
3129 return nativeResponseValue;
3132 export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
3133 if(!isWasmInitialized) {
3134 throw new Error("initializeWasm() must be awaited first!");
3136 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
3137 return nativeResponseValue;
3139 // struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
3141 export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
3142 if(!isWasmInitialized) {
3143 throw new Error("initializeWasm() must be awaited first!");
3145 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
3146 return nativeResponseValue;
3148 // struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
3150 export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
3151 if(!isWasmInitialized) {
3152 throw new Error("initializeWasm() must be awaited first!");
3154 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
3155 return nativeResponseValue;
3158 export class LDKClosureReason {
3159 protected constructor() {}
3162 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
3167 return nativeResponseValue;
3170 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): bigint {
3171 if(!isWasmInitialized) {
3172 throw new Error("initializeWasm() must be awaited first!");
3174 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
3175 return nativeResponseValue;
3178 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
3179 if(!isWasmInitialized) {
3180 throw new Error("initializeWasm() must be awaited first!");
3182 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
3183 return nativeResponseValue;
3186 export class LDKCOption_ClosureReasonZ {
3187 protected constructor() {}
3190 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
3191 if(!isWasmInitialized) {
3192 throw new Error("initializeWasm() must be awaited first!");
3194 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
3195 return nativeResponseValue;
3198 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
3203 return nativeResponseValue;
3205 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
3207 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
3212 return nativeResponseValue;
3214 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
3216 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
3221 return nativeResponseValue;
3224 export class LDKHTLCDestination {
3225 protected constructor() {}
3228 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
3229 if(!isWasmInitialized) {
3230 throw new Error("initializeWasm() must be awaited first!");
3232 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
3233 return nativeResponseValue;
3236 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
3237 if(!isWasmInitialized) {
3238 throw new Error("initializeWasm() must be awaited first!");
3240 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
3241 return nativeResponseValue;
3244 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
3245 if(!isWasmInitialized) {
3246 throw new Error("initializeWasm() must be awaited first!");
3248 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
3249 return nativeResponseValue;
3252 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
3257 return nativeResponseValue;
3260 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
3261 if(!isWasmInitialized) {
3262 throw new Error("initializeWasm() must be awaited first!");
3264 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
3265 return nativeResponseValue;
3268 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
3269 if(!isWasmInitialized) {
3270 throw new Error("initializeWasm() must be awaited first!");
3272 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
3273 return nativeResponseValue;
3276 export class LDKCOption_HTLCDestinationZ {
3277 protected constructor() {}
3280 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
3281 if(!isWasmInitialized) {
3282 throw new Error("initializeWasm() must be awaited first!");
3284 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
3285 return nativeResponseValue;
3288 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
3289 if(!isWasmInitialized) {
3290 throw new Error("initializeWasm() must be awaited first!");
3292 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
3293 return nativeResponseValue;
3295 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
3297 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
3298 if(!isWasmInitialized) {
3299 throw new Error("initializeWasm() must be awaited first!");
3301 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
3302 return nativeResponseValue;
3304 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
3306 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
3307 if(!isWasmInitialized) {
3308 throw new Error("initializeWasm() must be awaited first!");
3310 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
3311 return nativeResponseValue;
3313 // enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
3315 export function CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner: bigint): PaymentFailureReason {
3316 if(!isWasmInitialized) {
3317 throw new Error("initializeWasm() must be awaited first!");
3319 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner);
3320 return nativeResponseValue;
3322 // struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
3324 export function CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner: bigint): bigint {
3325 if(!isWasmInitialized) {
3326 throw new Error("initializeWasm() must be awaited first!");
3328 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner);
3329 return nativeResponseValue;
3332 export class LDKCOption_u128Z {
3333 protected constructor() {}
3336 export function LDKCOption_u128Z_ty_from_ptr(ptr: bigint): number {
3337 if(!isWasmInitialized) {
3338 throw new Error("initializeWasm() must be awaited first!");
3340 const nativeResponseValue = wasm.TS_LDKCOption_u128Z_ty_from_ptr(ptr);
3341 return nativeResponseValue;
3344 export function LDKCOption_u128Z_Some_get_some(ptr: bigint): number {
3345 if(!isWasmInitialized) {
3346 throw new Error("initializeWasm() must be awaited first!");
3348 const nativeResponseValue = wasm.TS_LDKCOption_u128Z_Some_get_some(ptr);
3349 return nativeResponseValue;
3352 export class LDKCOption_PaymentIdZ {
3353 protected constructor() {}
3356 export function LDKCOption_PaymentIdZ_ty_from_ptr(ptr: bigint): number {
3357 if(!isWasmInitialized) {
3358 throw new Error("initializeWasm() must be awaited first!");
3360 const nativeResponseValue = wasm.TS_LDKCOption_PaymentIdZ_ty_from_ptr(ptr);
3361 return nativeResponseValue;
3364 export function LDKCOption_PaymentIdZ_Some_get_some(ptr: bigint): number {
3365 if(!isWasmInitialized) {
3366 throw new Error("initializeWasm() must be awaited first!");
3368 const nativeResponseValue = wasm.TS_LDKCOption_PaymentIdZ_Some_get_some(ptr);
3369 return nativeResponseValue;
3372 export class LDKCOption_PaymentFailureReasonZ {
3373 protected constructor() {}
3376 export function LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr: bigint): number {
3377 if(!isWasmInitialized) {
3378 throw new Error("initializeWasm() must be awaited first!");
3380 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr);
3381 return nativeResponseValue;
3384 export function LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr: bigint): PaymentFailureReason {
3385 if(!isWasmInitialized) {
3386 throw new Error("initializeWasm() must be awaited first!");
3388 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr);
3389 return nativeResponseValue;
3392 export class LDKCOption_PaymentHashZ {
3393 protected constructor() {}
3396 export function LDKCOption_PaymentHashZ_ty_from_ptr(ptr: bigint): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_LDKCOption_PaymentHashZ_ty_from_ptr(ptr);
3401 return nativeResponseValue;
3404 export function LDKCOption_PaymentHashZ_Some_get_some(ptr: bigint): number {
3405 if(!isWasmInitialized) {
3406 throw new Error("initializeWasm() must be awaited first!");
3408 const nativeResponseValue = wasm.TS_LDKCOption_PaymentHashZ_Some_get_some(ptr);
3409 return nativeResponseValue;
3412 export class LDKBumpTransactionEvent {
3413 protected constructor() {}
3416 export function LDKBumpTransactionEvent_ty_from_ptr(ptr: bigint): number {
3417 if(!isWasmInitialized) {
3418 throw new Error("initializeWasm() must be awaited first!");
3420 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ty_from_ptr(ptr);
3421 return nativeResponseValue;
3424 export function LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr: bigint): number {
3425 if(!isWasmInitialized) {
3426 throw new Error("initializeWasm() must be awaited first!");
3428 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr);
3429 return nativeResponseValue;
3432 export function LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr: bigint): number {
3433 if(!isWasmInitialized) {
3434 throw new Error("initializeWasm() must be awaited first!");
3436 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr);
3437 return nativeResponseValue;
3440 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr: bigint): number {
3441 if(!isWasmInitialized) {
3442 throw new Error("initializeWasm() must be awaited first!");
3444 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr);
3445 return nativeResponseValue;
3448 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr: bigint): bigint {
3449 if(!isWasmInitialized) {
3450 throw new Error("initializeWasm() must be awaited first!");
3452 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr);
3453 return nativeResponseValue;
3456 export function LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr: bigint): bigint {
3457 if(!isWasmInitialized) {
3458 throw new Error("initializeWasm() must be awaited first!");
3460 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr);
3461 return nativeResponseValue;
3464 export function LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr: bigint): number {
3465 if(!isWasmInitialized) {
3466 throw new Error("initializeWasm() must be awaited first!");
3468 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr);
3469 return nativeResponseValue;
3472 export function LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr: bigint): number {
3473 if(!isWasmInitialized) {
3474 throw new Error("initializeWasm() must be awaited first!");
3476 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr);
3477 return nativeResponseValue;
3480 export function LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr: bigint): number {
3481 if(!isWasmInitialized) {
3482 throw new Error("initializeWasm() must be awaited first!");
3484 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr);
3485 return nativeResponseValue;
3488 export function LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr: bigint): number {
3489 if(!isWasmInitialized) {
3490 throw new Error("initializeWasm() must be awaited first!");
3492 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr);
3493 return nativeResponseValue;
3496 export function LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr: bigint): number {
3497 if(!isWasmInitialized) {
3498 throw new Error("initializeWasm() must be awaited first!");
3500 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr);
3501 return nativeResponseValue;
3504 export class LDKEvent {
3505 protected constructor() {}
3508 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
3509 if(!isWasmInitialized) {
3510 throw new Error("initializeWasm() must be awaited first!");
3512 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
3513 return nativeResponseValue;
3516 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
3517 if(!isWasmInitialized) {
3518 throw new Error("initializeWasm() must be awaited first!");
3520 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
3521 return nativeResponseValue;
3524 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
3525 if(!isWasmInitialized) {
3526 throw new Error("initializeWasm() must be awaited first!");
3528 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
3529 return nativeResponseValue;
3532 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
3533 if(!isWasmInitialized) {
3534 throw new Error("initializeWasm() must be awaited first!");
3536 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
3537 return nativeResponseValue;
3540 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
3541 if(!isWasmInitialized) {
3542 throw new Error("initializeWasm() must be awaited first!");
3544 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
3545 return nativeResponseValue;
3548 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
3549 if(!isWasmInitialized) {
3550 throw new Error("initializeWasm() must be awaited first!");
3552 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
3553 return nativeResponseValue;
3556 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
3557 if(!isWasmInitialized) {
3558 throw new Error("initializeWasm() must be awaited first!");
3560 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
3561 return nativeResponseValue;
3564 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
3565 if(!isWasmInitialized) {
3566 throw new Error("initializeWasm() must be awaited first!");
3568 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
3569 return nativeResponseValue;
3572 export function LDKEvent_PaymentClaimable_get_onion_fields(ptr: bigint): bigint {
3573 if(!isWasmInitialized) {
3574 throw new Error("initializeWasm() must be awaited first!");
3576 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_onion_fields(ptr);
3577 return nativeResponseValue;
3580 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
3581 if(!isWasmInitialized) {
3582 throw new Error("initializeWasm() must be awaited first!");
3584 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
3585 return nativeResponseValue;
3588 export function LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr: bigint): bigint {
3589 if(!isWasmInitialized) {
3590 throw new Error("initializeWasm() must be awaited first!");
3592 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr);
3593 return nativeResponseValue;
3596 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
3597 if(!isWasmInitialized) {
3598 throw new Error("initializeWasm() must be awaited first!");
3600 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
3601 return nativeResponseValue;
3604 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): number {
3605 if(!isWasmInitialized) {
3606 throw new Error("initializeWasm() must be awaited first!");
3608 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
3609 return nativeResponseValue;
3612 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
3613 if(!isWasmInitialized) {
3614 throw new Error("initializeWasm() must be awaited first!");
3616 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
3617 return nativeResponseValue;
3620 export function LDKEvent_PaymentClaimable_get_claim_deadline(ptr: bigint): bigint {
3621 if(!isWasmInitialized) {
3622 throw new Error("initializeWasm() must be awaited first!");
3624 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_claim_deadline(ptr);
3625 return nativeResponseValue;
3628 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
3629 if(!isWasmInitialized) {
3630 throw new Error("initializeWasm() must be awaited first!");
3632 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
3633 return nativeResponseValue;
3636 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
3637 if(!isWasmInitialized) {
3638 throw new Error("initializeWasm() must be awaited first!");
3640 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
3641 return nativeResponseValue;
3644 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
3645 if(!isWasmInitialized) {
3646 throw new Error("initializeWasm() must be awaited first!");
3648 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
3649 return nativeResponseValue;
3652 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
3653 if(!isWasmInitialized) {
3654 throw new Error("initializeWasm() must be awaited first!");
3656 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
3657 return nativeResponseValue;
3660 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): bigint {
3661 if(!isWasmInitialized) {
3662 throw new Error("initializeWasm() must be awaited first!");
3664 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
3665 return nativeResponseValue;
3668 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
3669 if(!isWasmInitialized) {
3670 throw new Error("initializeWasm() must be awaited first!");
3672 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
3673 return nativeResponseValue;
3676 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
3677 if(!isWasmInitialized) {
3678 throw new Error("initializeWasm() must be awaited first!");
3680 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
3681 return nativeResponseValue;
3684 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
3685 if(!isWasmInitialized) {
3686 throw new Error("initializeWasm() must be awaited first!");
3688 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
3689 return nativeResponseValue;
3692 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
3693 if(!isWasmInitialized) {
3694 throw new Error("initializeWasm() must be awaited first!");
3696 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
3697 return nativeResponseValue;
3700 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
3701 if(!isWasmInitialized) {
3702 throw new Error("initializeWasm() must be awaited first!");
3704 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
3705 return nativeResponseValue;
3708 export function LDKEvent_PaymentFailed_get_reason(ptr: bigint): bigint {
3709 if(!isWasmInitialized) {
3710 throw new Error("initializeWasm() must be awaited first!");
3712 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_reason(ptr);
3713 return nativeResponseValue;
3716 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
3717 if(!isWasmInitialized) {
3718 throw new Error("initializeWasm() must be awaited first!");
3720 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
3721 return nativeResponseValue;
3724 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): bigint {
3725 if(!isWasmInitialized) {
3726 throw new Error("initializeWasm() must be awaited first!");
3728 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
3729 return nativeResponseValue;
3732 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): bigint {
3733 if(!isWasmInitialized) {
3734 throw new Error("initializeWasm() must be awaited first!");
3736 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
3737 return nativeResponseValue;
3740 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): bigint {
3741 if(!isWasmInitialized) {
3742 throw new Error("initializeWasm() must be awaited first!");
3744 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
3745 return nativeResponseValue;
3748 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
3749 if(!isWasmInitialized) {
3750 throw new Error("initializeWasm() must be awaited first!");
3752 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
3753 return nativeResponseValue;
3756 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
3757 if(!isWasmInitialized) {
3758 throw new Error("initializeWasm() must be awaited first!");
3760 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
3761 return nativeResponseValue;
3764 export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
3765 if(!isWasmInitialized) {
3766 throw new Error("initializeWasm() must be awaited first!");
3768 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_failure(ptr);
3769 return nativeResponseValue;
3772 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): bigint {
3773 if(!isWasmInitialized) {
3774 throw new Error("initializeWasm() must be awaited first!");
3776 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
3777 return nativeResponseValue;
3780 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
3781 if(!isWasmInitialized) {
3782 throw new Error("initializeWasm() must be awaited first!");
3784 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
3785 return nativeResponseValue;
3788 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
3789 if(!isWasmInitialized) {
3790 throw new Error("initializeWasm() must be awaited first!");
3792 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
3793 return nativeResponseValue;
3796 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
3797 if(!isWasmInitialized) {
3798 throw new Error("initializeWasm() must be awaited first!");
3800 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
3801 return nativeResponseValue;
3804 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): bigint {
3805 if(!isWasmInitialized) {
3806 throw new Error("initializeWasm() must be awaited first!");
3808 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
3809 return nativeResponseValue;
3812 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
3813 if(!isWasmInitialized) {
3814 throw new Error("initializeWasm() must be awaited first!");
3816 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
3817 return nativeResponseValue;
3820 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
3821 if(!isWasmInitialized) {
3822 throw new Error("initializeWasm() must be awaited first!");
3824 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
3825 return nativeResponseValue;
3828 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): bigint {
3829 if(!isWasmInitialized) {
3830 throw new Error("initializeWasm() must be awaited first!");
3832 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
3833 return nativeResponseValue;
3836 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
3837 if(!isWasmInitialized) {
3838 throw new Error("initializeWasm() must be awaited first!");
3840 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
3841 return nativeResponseValue;
3844 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
3845 if(!isWasmInitialized) {
3846 throw new Error("initializeWasm() must be awaited first!");
3848 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
3849 return nativeResponseValue;
3852 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
3853 if(!isWasmInitialized) {
3854 throw new Error("initializeWasm() must be awaited first!");
3856 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
3857 return nativeResponseValue;
3860 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
3861 if(!isWasmInitialized) {
3862 throw new Error("initializeWasm() must be awaited first!");
3864 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
3865 return nativeResponseValue;
3868 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
3869 if(!isWasmInitialized) {
3870 throw new Error("initializeWasm() must be awaited first!");
3872 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
3873 return nativeResponseValue;
3876 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
3877 if(!isWasmInitialized) {
3878 throw new Error("initializeWasm() must be awaited first!");
3880 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
3881 return nativeResponseValue;
3884 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
3885 if(!isWasmInitialized) {
3886 throw new Error("initializeWasm() must be awaited first!");
3888 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
3889 return nativeResponseValue;
3892 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
3893 if(!isWasmInitialized) {
3894 throw new Error("initializeWasm() must be awaited first!");
3896 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
3897 return nativeResponseValue;
3900 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): number {
3901 if(!isWasmInitialized) {
3902 throw new Error("initializeWasm() must be awaited first!");
3904 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
3905 return nativeResponseValue;
3908 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): number {
3909 if(!isWasmInitialized) {
3910 throw new Error("initializeWasm() must be awaited first!");
3912 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
3913 return nativeResponseValue;
3916 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
3917 if(!isWasmInitialized) {
3918 throw new Error("initializeWasm() must be awaited first!");
3920 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
3921 return nativeResponseValue;
3924 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
3925 if(!isWasmInitialized) {
3926 throw new Error("initializeWasm() must be awaited first!");
3928 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
3929 return nativeResponseValue;
3932 export function LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr: bigint): bigint {
3933 if(!isWasmInitialized) {
3934 throw new Error("initializeWasm() must be awaited first!");
3936 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr);
3937 return nativeResponseValue;
3940 export function LDKEvent_ChannelPending_get_channel_id(ptr: bigint): number {
3941 if(!isWasmInitialized) {
3942 throw new Error("initializeWasm() must be awaited first!");
3944 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_id(ptr);
3945 return nativeResponseValue;
3948 export function LDKEvent_ChannelPending_get_user_channel_id(ptr: bigint): number {
3949 if(!isWasmInitialized) {
3950 throw new Error("initializeWasm() must be awaited first!");
3952 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_user_channel_id(ptr);
3953 return nativeResponseValue;
3956 export function LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr: bigint): number {
3957 if(!isWasmInitialized) {
3958 throw new Error("initializeWasm() must be awaited first!");
3960 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr);
3961 return nativeResponseValue;
3964 export function LDKEvent_ChannelPending_get_counterparty_node_id(ptr: bigint): number {
3965 if(!isWasmInitialized) {
3966 throw new Error("initializeWasm() must be awaited first!");
3968 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_counterparty_node_id(ptr);
3969 return nativeResponseValue;
3972 export function LDKEvent_ChannelPending_get_funding_txo(ptr: bigint): bigint {
3973 if(!isWasmInitialized) {
3974 throw new Error("initializeWasm() must be awaited first!");
3976 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_funding_txo(ptr);
3977 return nativeResponseValue;
3980 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
3981 if(!isWasmInitialized) {
3982 throw new Error("initializeWasm() must be awaited first!");
3984 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
3985 return nativeResponseValue;
3988 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
3989 if(!isWasmInitialized) {
3990 throw new Error("initializeWasm() must be awaited first!");
3992 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
3993 return nativeResponseValue;
3996 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
3997 if(!isWasmInitialized) {
3998 throw new Error("initializeWasm() must be awaited first!");
4000 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
4001 return nativeResponseValue;
4004 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
4005 if(!isWasmInitialized) {
4006 throw new Error("initializeWasm() must be awaited first!");
4008 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
4009 return nativeResponseValue;
4012 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
4013 if(!isWasmInitialized) {
4014 throw new Error("initializeWasm() must be awaited first!");
4016 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
4017 return nativeResponseValue;
4020 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
4021 if(!isWasmInitialized) {
4022 throw new Error("initializeWasm() must be awaited first!");
4024 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
4025 return nativeResponseValue;
4028 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
4029 if(!isWasmInitialized) {
4030 throw new Error("initializeWasm() must be awaited first!");
4032 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
4033 return nativeResponseValue;
4036 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
4037 if(!isWasmInitialized) {
4038 throw new Error("initializeWasm() must be awaited first!");
4040 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
4041 return nativeResponseValue;
4044 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
4045 if(!isWasmInitialized) {
4046 throw new Error("initializeWasm() must be awaited first!");
4048 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
4049 return nativeResponseValue;
4052 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
4053 if(!isWasmInitialized) {
4054 throw new Error("initializeWasm() must be awaited first!");
4056 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
4057 return nativeResponseValue;
4060 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
4061 if(!isWasmInitialized) {
4062 throw new Error("initializeWasm() must be awaited first!");
4064 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
4065 return nativeResponseValue;
4068 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
4069 if(!isWasmInitialized) {
4070 throw new Error("initializeWasm() must be awaited first!");
4072 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
4073 return nativeResponseValue;
4076 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
4077 if(!isWasmInitialized) {
4078 throw new Error("initializeWasm() must be awaited first!");
4080 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
4081 return nativeResponseValue;
4084 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
4085 if(!isWasmInitialized) {
4086 throw new Error("initializeWasm() must be awaited first!");
4088 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
4089 return nativeResponseValue;
4092 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
4093 if(!isWasmInitialized) {
4094 throw new Error("initializeWasm() must be awaited first!");
4096 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
4097 return nativeResponseValue;
4100 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
4101 if(!isWasmInitialized) {
4102 throw new Error("initializeWasm() must be awaited first!");
4104 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
4105 return nativeResponseValue;
4108 export function LDKEvent_BumpTransaction_get_bump_transaction(ptr: bigint): bigint {
4109 if(!isWasmInitialized) {
4110 throw new Error("initializeWasm() must be awaited first!");
4112 const nativeResponseValue = wasm.TS_LDKEvent_BumpTransaction_get_bump_transaction(ptr);
4113 return nativeResponseValue;
4116 export class LDKCOption_EventZ {
4117 protected constructor() {}
4120 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
4121 if(!isWasmInitialized) {
4122 throw new Error("initializeWasm() must be awaited first!");
4124 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
4125 return nativeResponseValue;
4128 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
4129 if(!isWasmInitialized) {
4130 throw new Error("initializeWasm() must be awaited first!");
4132 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
4133 return nativeResponseValue;
4135 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
4137 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
4138 if(!isWasmInitialized) {
4139 throw new Error("initializeWasm() must be awaited first!");
4141 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
4142 return nativeResponseValue;
4144 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
4146 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
4147 if(!isWasmInitialized) {
4148 throw new Error("initializeWasm() must be awaited first!");
4150 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
4151 return nativeResponseValue;
4154 export class LDKErrorAction {
4155 protected constructor() {}
4158 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
4159 if(!isWasmInitialized) {
4160 throw new Error("initializeWasm() must be awaited first!");
4162 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
4163 return nativeResponseValue;
4166 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
4171 return nativeResponseValue;
4174 export function LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr: bigint): bigint {
4175 if(!isWasmInitialized) {
4176 throw new Error("initializeWasm() must be awaited first!");
4178 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr);
4179 return nativeResponseValue;
4182 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
4183 if(!isWasmInitialized) {
4184 throw new Error("initializeWasm() must be awaited first!");
4186 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
4187 return nativeResponseValue;
4190 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
4191 if(!isWasmInitialized) {
4192 throw new Error("initializeWasm() must be awaited first!");
4194 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
4195 return nativeResponseValue;
4198 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
4199 if(!isWasmInitialized) {
4200 throw new Error("initializeWasm() must be awaited first!");
4202 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
4203 return nativeResponseValue;
4206 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
4207 if(!isWasmInitialized) {
4208 throw new Error("initializeWasm() must be awaited first!");
4210 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
4211 return nativeResponseValue;
4214 export class LDKMessageSendEvent {
4215 protected constructor() {}
4218 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
4219 if(!isWasmInitialized) {
4220 throw new Error("initializeWasm() must be awaited first!");
4222 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
4223 return nativeResponseValue;
4226 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
4227 if(!isWasmInitialized) {
4228 throw new Error("initializeWasm() must be awaited first!");
4230 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
4231 return nativeResponseValue;
4234 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
4235 if(!isWasmInitialized) {
4236 throw new Error("initializeWasm() must be awaited first!");
4238 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
4239 return nativeResponseValue;
4242 export function LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr: bigint): number {
4243 if(!isWasmInitialized) {
4244 throw new Error("initializeWasm() must be awaited first!");
4246 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr);
4247 return nativeResponseValue;
4250 export function LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr: bigint): bigint {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr);
4255 return nativeResponseValue;
4258 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
4259 if(!isWasmInitialized) {
4260 throw new Error("initializeWasm() must be awaited first!");
4262 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
4263 return nativeResponseValue;
4266 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
4267 if(!isWasmInitialized) {
4268 throw new Error("initializeWasm() must be awaited first!");
4270 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
4271 return nativeResponseValue;
4274 export function LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr: bigint): number {
4275 if(!isWasmInitialized) {
4276 throw new Error("initializeWasm() must be awaited first!");
4278 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr);
4279 return nativeResponseValue;
4282 export function LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr: bigint): bigint {
4283 if(!isWasmInitialized) {
4284 throw new Error("initializeWasm() must be awaited first!");
4286 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr);
4287 return nativeResponseValue;
4290 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
4291 if(!isWasmInitialized) {
4292 throw new Error("initializeWasm() must be awaited first!");
4294 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
4295 return nativeResponseValue;
4298 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
4299 if(!isWasmInitialized) {
4300 throw new Error("initializeWasm() must be awaited first!");
4302 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
4303 return nativeResponseValue;
4306 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
4307 if(!isWasmInitialized) {
4308 throw new Error("initializeWasm() must be awaited first!");
4310 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
4311 return nativeResponseValue;
4314 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
4315 if(!isWasmInitialized) {
4316 throw new Error("initializeWasm() must be awaited first!");
4318 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
4319 return nativeResponseValue;
4322 export function LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr: bigint): number {
4323 if(!isWasmInitialized) {
4324 throw new Error("initializeWasm() must be awaited first!");
4326 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr);
4327 return nativeResponseValue;
4330 export function LDKMessageSendEvent_SendTxAddInput_get_msg(ptr: bigint): bigint {
4331 if(!isWasmInitialized) {
4332 throw new Error("initializeWasm() must be awaited first!");
4334 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_msg(ptr);
4335 return nativeResponseValue;
4338 export function LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr: bigint): number {
4339 if(!isWasmInitialized) {
4340 throw new Error("initializeWasm() must be awaited first!");
4342 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr);
4343 return nativeResponseValue;
4346 export function LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr: bigint): bigint {
4347 if(!isWasmInitialized) {
4348 throw new Error("initializeWasm() must be awaited first!");
4350 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr);
4351 return nativeResponseValue;
4354 export function LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr: bigint): number {
4355 if(!isWasmInitialized) {
4356 throw new Error("initializeWasm() must be awaited first!");
4358 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr);
4359 return nativeResponseValue;
4362 export function LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr: bigint): bigint {
4363 if(!isWasmInitialized) {
4364 throw new Error("initializeWasm() must be awaited first!");
4366 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr);
4367 return nativeResponseValue;
4370 export function LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr: bigint): number {
4371 if(!isWasmInitialized) {
4372 throw new Error("initializeWasm() must be awaited first!");
4374 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr);
4375 return nativeResponseValue;
4378 export function LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr: bigint): bigint {
4379 if(!isWasmInitialized) {
4380 throw new Error("initializeWasm() must be awaited first!");
4382 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr);
4383 return nativeResponseValue;
4386 export function LDKMessageSendEvent_SendTxComplete_get_node_id(ptr: bigint): number {
4387 if(!isWasmInitialized) {
4388 throw new Error("initializeWasm() must be awaited first!");
4390 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_node_id(ptr);
4391 return nativeResponseValue;
4394 export function LDKMessageSendEvent_SendTxComplete_get_msg(ptr: bigint): bigint {
4395 if(!isWasmInitialized) {
4396 throw new Error("initializeWasm() must be awaited first!");
4398 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_msg(ptr);
4399 return nativeResponseValue;
4402 export function LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr: bigint): number {
4403 if(!isWasmInitialized) {
4404 throw new Error("initializeWasm() must be awaited first!");
4406 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr);
4407 return nativeResponseValue;
4410 export function LDKMessageSendEvent_SendTxSignatures_get_msg(ptr: bigint): bigint {
4411 if(!isWasmInitialized) {
4412 throw new Error("initializeWasm() must be awaited first!");
4414 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_msg(ptr);
4415 return nativeResponseValue;
4418 export function LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr: bigint): number {
4419 if(!isWasmInitialized) {
4420 throw new Error("initializeWasm() must be awaited first!");
4422 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr);
4423 return nativeResponseValue;
4426 export function LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr: bigint): bigint {
4427 if(!isWasmInitialized) {
4428 throw new Error("initializeWasm() must be awaited first!");
4430 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr);
4431 return nativeResponseValue;
4434 export function LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr: bigint): number {
4435 if(!isWasmInitialized) {
4436 throw new Error("initializeWasm() must be awaited first!");
4438 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr);
4439 return nativeResponseValue;
4442 export function LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr: bigint): bigint {
4443 if(!isWasmInitialized) {
4444 throw new Error("initializeWasm() must be awaited first!");
4446 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr);
4447 return nativeResponseValue;
4450 export function LDKMessageSendEvent_SendTxAbort_get_node_id(ptr: bigint): number {
4451 if(!isWasmInitialized) {
4452 throw new Error("initializeWasm() must be awaited first!");
4454 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_node_id(ptr);
4455 return nativeResponseValue;
4458 export function LDKMessageSendEvent_SendTxAbort_get_msg(ptr: bigint): bigint {
4459 if(!isWasmInitialized) {
4460 throw new Error("initializeWasm() must be awaited first!");
4462 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_msg(ptr);
4463 return nativeResponseValue;
4466 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
4467 if(!isWasmInitialized) {
4468 throw new Error("initializeWasm() must be awaited first!");
4470 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
4471 return nativeResponseValue;
4474 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
4475 if(!isWasmInitialized) {
4476 throw new Error("initializeWasm() must be awaited first!");
4478 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
4479 return nativeResponseValue;
4482 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
4483 if(!isWasmInitialized) {
4484 throw new Error("initializeWasm() must be awaited first!");
4486 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
4487 return nativeResponseValue;
4490 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
4491 if(!isWasmInitialized) {
4492 throw new Error("initializeWasm() must be awaited first!");
4494 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
4495 return nativeResponseValue;
4498 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
4499 if(!isWasmInitialized) {
4500 throw new Error("initializeWasm() must be awaited first!");
4502 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
4503 return nativeResponseValue;
4506 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
4507 if(!isWasmInitialized) {
4508 throw new Error("initializeWasm() must be awaited first!");
4510 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
4511 return nativeResponseValue;
4514 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
4515 if(!isWasmInitialized) {
4516 throw new Error("initializeWasm() must be awaited first!");
4518 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
4519 return nativeResponseValue;
4522 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
4523 if(!isWasmInitialized) {
4524 throw new Error("initializeWasm() must be awaited first!");
4526 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
4527 return nativeResponseValue;
4530 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
4531 if(!isWasmInitialized) {
4532 throw new Error("initializeWasm() must be awaited first!");
4534 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
4535 return nativeResponseValue;
4538 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
4539 if(!isWasmInitialized) {
4540 throw new Error("initializeWasm() must be awaited first!");
4542 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
4543 return nativeResponseValue;
4546 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
4547 if(!isWasmInitialized) {
4548 throw new Error("initializeWasm() must be awaited first!");
4550 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
4551 return nativeResponseValue;
4554 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
4555 if(!isWasmInitialized) {
4556 throw new Error("initializeWasm() must be awaited first!");
4558 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
4559 return nativeResponseValue;
4562 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
4563 if(!isWasmInitialized) {
4564 throw new Error("initializeWasm() must be awaited first!");
4566 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
4567 return nativeResponseValue;
4570 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
4571 if(!isWasmInitialized) {
4572 throw new Error("initializeWasm() must be awaited first!");
4574 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
4575 return nativeResponseValue;
4578 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
4579 if(!isWasmInitialized) {
4580 throw new Error("initializeWasm() must be awaited first!");
4582 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
4583 return nativeResponseValue;
4586 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
4587 if(!isWasmInitialized) {
4588 throw new Error("initializeWasm() must be awaited first!");
4590 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
4591 return nativeResponseValue;
4594 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
4595 if(!isWasmInitialized) {
4596 throw new Error("initializeWasm() must be awaited first!");
4598 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
4599 return nativeResponseValue;
4602 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
4603 if(!isWasmInitialized) {
4604 throw new Error("initializeWasm() must be awaited first!");
4606 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
4607 return nativeResponseValue;
4610 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
4611 if(!isWasmInitialized) {
4612 throw new Error("initializeWasm() must be awaited first!");
4614 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
4615 return nativeResponseValue;
4618 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
4619 if(!isWasmInitialized) {
4620 throw new Error("initializeWasm() must be awaited first!");
4622 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
4623 return nativeResponseValue;
4626 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
4627 if(!isWasmInitialized) {
4628 throw new Error("initializeWasm() must be awaited first!");
4630 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
4631 return nativeResponseValue;
4634 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
4635 if(!isWasmInitialized) {
4636 throw new Error("initializeWasm() must be awaited first!");
4638 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
4639 return nativeResponseValue;
4642 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
4643 if(!isWasmInitialized) {
4644 throw new Error("initializeWasm() must be awaited first!");
4646 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
4647 return nativeResponseValue;
4650 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
4651 if(!isWasmInitialized) {
4652 throw new Error("initializeWasm() must be awaited first!");
4654 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
4655 return nativeResponseValue;
4658 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
4659 if(!isWasmInitialized) {
4660 throw new Error("initializeWasm() must be awaited first!");
4662 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
4663 return nativeResponseValue;
4666 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
4667 if(!isWasmInitialized) {
4668 throw new Error("initializeWasm() must be awaited first!");
4670 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
4671 return nativeResponseValue;
4674 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
4675 if(!isWasmInitialized) {
4676 throw new Error("initializeWasm() must be awaited first!");
4678 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
4679 return nativeResponseValue;
4682 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
4683 if(!isWasmInitialized) {
4684 throw new Error("initializeWasm() must be awaited first!");
4686 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
4687 return nativeResponseValue;
4690 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
4691 if(!isWasmInitialized) {
4692 throw new Error("initializeWasm() must be awaited first!");
4694 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
4695 return nativeResponseValue;
4698 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
4699 if(!isWasmInitialized) {
4700 throw new Error("initializeWasm() must be awaited first!");
4702 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
4703 return nativeResponseValue;
4706 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
4707 if(!isWasmInitialized) {
4708 throw new Error("initializeWasm() must be awaited first!");
4710 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
4711 return nativeResponseValue;
4714 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
4715 if(!isWasmInitialized) {
4716 throw new Error("initializeWasm() must be awaited first!");
4718 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
4719 return nativeResponseValue;
4722 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
4723 if(!isWasmInitialized) {
4724 throw new Error("initializeWasm() must be awaited first!");
4726 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
4727 return nativeResponseValue;
4729 // struct LDKOffer CResult_OfferBolt12ParseErrorZ_get_ok(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
4731 export function CResult_OfferBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
4732 if(!isWasmInitialized) {
4733 throw new Error("initializeWasm() must be awaited first!");
4735 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_ok(owner);
4736 return nativeResponseValue;
4738 // struct LDKBolt12ParseError CResult_OfferBolt12ParseErrorZ_get_err(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
4740 export function CResult_OfferBolt12ParseErrorZ_get_err(owner: bigint): bigint {
4741 if(!isWasmInitialized) {
4742 throw new Error("initializeWasm() must be awaited first!");
4744 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_err(owner);
4745 return nativeResponseValue;
4747 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
4749 export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
4750 if(!isWasmInitialized) {
4751 throw new Error("initializeWasm() must be awaited first!");
4753 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
4754 return nativeResponseValue;
4756 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
4758 export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
4759 if(!isWasmInitialized) {
4760 throw new Error("initializeWasm() must be awaited first!");
4762 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
4763 return nativeResponseValue;
4765 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4767 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
4768 if(!isWasmInitialized) {
4769 throw new Error("initializeWasm() must be awaited first!");
4771 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
4772 return nativeResponseValue;
4774 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4776 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
4777 if(!isWasmInitialized) {
4778 throw new Error("initializeWasm() must be awaited first!");
4780 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
4781 return nativeResponseValue;
4783 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4785 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
4786 if(!isWasmInitialized) {
4787 throw new Error("initializeWasm() must be awaited first!");
4789 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
4790 return nativeResponseValue;
4792 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4794 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
4795 if(!isWasmInitialized) {
4796 throw new Error("initializeWasm() must be awaited first!");
4798 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
4799 return nativeResponseValue;
4801 // struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
4803 export function CResult_TxOutUtxoLookupErrorZ_get_ok(owner: bigint): bigint {
4804 if(!isWasmInitialized) {
4805 throw new Error("initializeWasm() must be awaited first!");
4807 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_ok(owner);
4808 return nativeResponseValue;
4810 // enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
4812 export function CResult_TxOutUtxoLookupErrorZ_get_err(owner: bigint): UtxoLookupError {
4813 if(!isWasmInitialized) {
4814 throw new Error("initializeWasm() must be awaited first!");
4816 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_err(owner);
4817 return nativeResponseValue;
4820 export class LDKUtxoResult {
4821 protected constructor() {}
4824 export function LDKUtxoResult_ty_from_ptr(ptr: bigint): number {
4825 if(!isWasmInitialized) {
4826 throw new Error("initializeWasm() must be awaited first!");
4828 const nativeResponseValue = wasm.TS_LDKUtxoResult_ty_from_ptr(ptr);
4829 return nativeResponseValue;
4832 export function LDKUtxoResult_Sync_get_sync(ptr: bigint): bigint {
4833 if(!isWasmInitialized) {
4834 throw new Error("initializeWasm() must be awaited first!");
4836 const nativeResponseValue = wasm.TS_LDKUtxoResult_Sync_get_sync(ptr);
4837 return nativeResponseValue;
4840 export function LDKUtxoResult_Async_get_async(ptr: bigint): bigint {
4841 if(!isWasmInitialized) {
4842 throw new Error("initializeWasm() must be awaited first!");
4844 const nativeResponseValue = wasm.TS_LDKUtxoResult_Async_get_async(ptr);
4845 return nativeResponseValue;
4848 export interface LDKUtxoLookup {
4849 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
4853 export function LDKUtxoLookup_new(impl: LDKUtxoLookup): [bigint, number] {
4854 if(!isWasmInitialized) {
4855 throw new Error("initializeWasm() must be awaited first!");
4857 var new_obj_idx = js_objs.length;
4858 for (var i = 0; i < js_objs.length; i++) {
4859 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4861 js_objs[i] = new WeakRef(impl);
4862 return [wasm.TS_LDKUtxoLookup_new(i), i];
4864 // LDKUtxoResult UtxoLookup_get_utxo LDKUtxoLookup *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
4866 export function UtxoLookup_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
4867 if(!isWasmInitialized) {
4868 throw new Error("initializeWasm() must be awaited first!");
4870 const nativeResponseValue = wasm.TS_UtxoLookup_get_utxo(this_arg, genesis_hash, short_channel_id);
4871 return nativeResponseValue;
4874 export class LDKCOption_UtxoLookupZ {
4875 protected constructor() {}
4878 export function LDKCOption_UtxoLookupZ_ty_from_ptr(ptr: bigint): number {
4879 if(!isWasmInitialized) {
4880 throw new Error("initializeWasm() must be awaited first!");
4882 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_ty_from_ptr(ptr);
4883 return nativeResponseValue;
4886 export function LDKCOption_UtxoLookupZ_Some_get_some(ptr: bigint): bigint {
4887 if(!isWasmInitialized) {
4888 throw new Error("initializeWasm() must be awaited first!");
4890 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_Some_get_some(ptr);
4891 return nativeResponseValue;
4893 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4895 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
4896 if(!isWasmInitialized) {
4897 throw new Error("initializeWasm() must be awaited first!");
4899 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
4900 // debug statements here
4902 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4904 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
4905 if(!isWasmInitialized) {
4906 throw new Error("initializeWasm() must be awaited first!");
4908 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
4909 return nativeResponseValue;
4911 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4913 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
4914 if(!isWasmInitialized) {
4915 throw new Error("initializeWasm() must be awaited first!");
4917 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
4918 return nativeResponseValue;
4920 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4922 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
4923 if(!isWasmInitialized) {
4924 throw new Error("initializeWasm() must be awaited first!");
4926 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
4927 return nativeResponseValue;
4929 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4931 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
4932 if(!isWasmInitialized) {
4933 throw new Error("initializeWasm() must be awaited first!");
4935 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
4936 return nativeResponseValue;
4938 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4940 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
4941 if(!isWasmInitialized) {
4942 throw new Error("initializeWasm() must be awaited first!");
4944 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
4945 return nativeResponseValue;
4947 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4949 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
4950 if(!isWasmInitialized) {
4951 throw new Error("initializeWasm() must be awaited first!");
4953 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
4954 return nativeResponseValue;
4957 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
4958 protected constructor() {}
4961 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
4962 if(!isWasmInitialized) {
4963 throw new Error("initializeWasm() must be awaited first!");
4965 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
4966 return nativeResponseValue;
4969 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
4970 if(!isWasmInitialized) {
4971 throw new Error("initializeWasm() must be awaited first!");
4973 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
4974 return nativeResponseValue;
4976 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4978 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4979 if(!isWasmInitialized) {
4980 throw new Error("initializeWasm() must be awaited first!");
4982 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
4983 return nativeResponseValue;
4985 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4987 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4988 if(!isWasmInitialized) {
4989 throw new Error("initializeWasm() must be awaited first!");
4991 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
4992 return nativeResponseValue;
4994 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4996 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4997 if(!isWasmInitialized) {
4998 throw new Error("initializeWasm() must be awaited first!");
5000 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
5001 return nativeResponseValue;
5003 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
5005 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
5006 if(!isWasmInitialized) {
5007 throw new Error("initializeWasm() must be awaited first!");
5009 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
5010 return nativeResponseValue;
5012 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
5014 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
5015 if(!isWasmInitialized) {
5016 throw new Error("initializeWasm() must be awaited first!");
5018 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
5019 return nativeResponseValue;
5021 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
5023 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
5024 if(!isWasmInitialized) {
5025 throw new Error("initializeWasm() must be awaited first!");
5027 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
5028 return nativeResponseValue;
5031 export class LDKNetAddress {
5032 protected constructor() {}
5035 export function LDKNetAddress_ty_from_ptr(ptr: bigint): number {
5036 if(!isWasmInitialized) {
5037 throw new Error("initializeWasm() must be awaited first!");
5039 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
5040 return nativeResponseValue;
5043 export function LDKNetAddress_IPv4_get_addr(ptr: bigint): number {
5044 if(!isWasmInitialized) {
5045 throw new Error("initializeWasm() must be awaited first!");
5047 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
5048 return nativeResponseValue;
5051 export function LDKNetAddress_IPv4_get_port(ptr: bigint): number {
5052 if(!isWasmInitialized) {
5053 throw new Error("initializeWasm() must be awaited first!");
5055 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
5056 return nativeResponseValue;
5059 export function LDKNetAddress_IPv6_get_addr(ptr: bigint): number {
5060 if(!isWasmInitialized) {
5061 throw new Error("initializeWasm() must be awaited first!");
5063 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
5064 return nativeResponseValue;
5067 export function LDKNetAddress_IPv6_get_port(ptr: bigint): number {
5068 if(!isWasmInitialized) {
5069 throw new Error("initializeWasm() must be awaited first!");
5071 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
5072 return nativeResponseValue;
5075 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: bigint): number {
5076 if(!isWasmInitialized) {
5077 throw new Error("initializeWasm() must be awaited first!");
5079 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
5080 return nativeResponseValue;
5083 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
5084 if(!isWasmInitialized) {
5085 throw new Error("initializeWasm() must be awaited first!");
5087 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
5088 return nativeResponseValue;
5091 export function LDKNetAddress_OnionV3_get_checksum(ptr: bigint): number {
5092 if(!isWasmInitialized) {
5093 throw new Error("initializeWasm() must be awaited first!");
5095 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
5096 return nativeResponseValue;
5099 export function LDKNetAddress_OnionV3_get_version(ptr: bigint): number {
5100 if(!isWasmInitialized) {
5101 throw new Error("initializeWasm() must be awaited first!");
5103 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
5104 return nativeResponseValue;
5107 export function LDKNetAddress_OnionV3_get_port(ptr: bigint): number {
5108 if(!isWasmInitialized) {
5109 throw new Error("initializeWasm() must be awaited first!");
5111 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
5112 return nativeResponseValue;
5115 export function LDKNetAddress_Hostname_get_hostname(ptr: bigint): bigint {
5116 if(!isWasmInitialized) {
5117 throw new Error("initializeWasm() must be awaited first!");
5119 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
5120 return nativeResponseValue;
5123 export function LDKNetAddress_Hostname_get_port(ptr: bigint): number {
5124 if(!isWasmInitialized) {
5125 throw new Error("initializeWasm() must be awaited first!");
5127 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
5128 return nativeResponseValue;
5130 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
5132 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
5133 if(!isWasmInitialized) {
5134 throw new Error("initializeWasm() must be awaited first!");
5136 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
5137 return nativeResponseValue;
5139 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
5141 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
5142 if(!isWasmInitialized) {
5143 throw new Error("initializeWasm() must be awaited first!");
5145 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
5146 return nativeResponseValue;
5148 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
5150 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
5151 if(!isWasmInitialized) {
5152 throw new Error("initializeWasm() must be awaited first!");
5154 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
5155 return nativeResponseValue;
5157 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
5159 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
5160 if(!isWasmInitialized) {
5161 throw new Error("initializeWasm() must be awaited first!");
5163 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
5164 return nativeResponseValue;
5166 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
5168 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
5169 if(!isWasmInitialized) {
5170 throw new Error("initializeWasm() must be awaited first!");
5172 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
5173 return nativeResponseValue;
5175 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
5177 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
5178 if(!isWasmInitialized) {
5179 throw new Error("initializeWasm() must be awaited first!");
5181 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
5182 return nativeResponseValue;
5184 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
5186 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
5187 if(!isWasmInitialized) {
5188 throw new Error("initializeWasm() must be awaited first!");
5190 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
5191 return nativeResponseValue;
5193 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
5195 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
5196 if(!isWasmInitialized) {
5197 throw new Error("initializeWasm() must be awaited first!");
5199 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
5200 return nativeResponseValue;
5203 export class LDKCOption_CVec_NetAddressZZ {
5204 protected constructor() {}
5207 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: bigint): number {
5208 if(!isWasmInitialized) {
5209 throw new Error("initializeWasm() must be awaited first!");
5211 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
5212 return nativeResponseValue;
5215 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: bigint): number {
5216 if(!isWasmInitialized) {
5217 throw new Error("initializeWasm() must be awaited first!");
5219 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
5220 return nativeResponseValue;
5223 export class LDKCOption_TxOutZ {
5224 protected constructor() {}
5227 export function LDKCOption_TxOutZ_ty_from_ptr(ptr: bigint): number {
5228 if(!isWasmInitialized) {
5229 throw new Error("initializeWasm() must be awaited first!");
5231 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_ty_from_ptr(ptr);
5232 return nativeResponseValue;
5235 export function LDKCOption_TxOutZ_Some_get_some(ptr: bigint): bigint {
5236 if(!isWasmInitialized) {
5237 throw new Error("initializeWasm() must be awaited first!");
5239 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_Some_get_some(ptr);
5240 return nativeResponseValue;
5242 // struct LDKCoinSelection CResult_CoinSelectionNoneZ_get_ok(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
5244 export function CResult_CoinSelectionNoneZ_get_ok(owner: bigint): bigint {
5245 if(!isWasmInitialized) {
5246 throw new Error("initializeWasm() must be awaited first!");
5248 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_ok(owner);
5249 return nativeResponseValue;
5251 // void CResult_CoinSelectionNoneZ_get_err(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
5253 export function CResult_CoinSelectionNoneZ_get_err(owner: bigint): void {
5254 if(!isWasmInitialized) {
5255 throw new Error("initializeWasm() must be awaited first!");
5257 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_err(owner);
5258 // debug statements here
5260 // struct LDKCVec_UtxoZ CResult_CVec_UtxoZNoneZ_get_ok(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
5262 export function CResult_CVec_UtxoZNoneZ_get_ok(owner: bigint): number {
5263 if(!isWasmInitialized) {
5264 throw new Error("initializeWasm() must be awaited first!");
5266 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_ok(owner);
5267 return nativeResponseValue;
5269 // void CResult_CVec_UtxoZNoneZ_get_err(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
5271 export function CResult_CVec_UtxoZNoneZ_get_err(owner: bigint): void {
5272 if(!isWasmInitialized) {
5273 throw new Error("initializeWasm() must be awaited first!");
5275 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_err(owner);
5276 // debug statements here
5279 export class LDKCOption_u16Z {
5280 protected constructor() {}
5283 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
5284 if(!isWasmInitialized) {
5285 throw new Error("initializeWasm() must be awaited first!");
5287 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
5288 return nativeResponseValue;
5291 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
5292 if(!isWasmInitialized) {
5293 throw new Error("initializeWasm() must be awaited first!");
5295 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
5296 return nativeResponseValue;
5299 export class LDKCOption_ChannelShutdownStateZ {
5300 protected constructor() {}
5303 export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
5304 if(!isWasmInitialized) {
5305 throw new Error("initializeWasm() must be awaited first!");
5307 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
5308 return nativeResponseValue;
5311 export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
5312 if(!isWasmInitialized) {
5313 throw new Error("initializeWasm() must be awaited first!");
5315 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
5316 return nativeResponseValue;
5318 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
5320 export function CResult__u832APIErrorZ_get_ok(owner: bigint): number {
5321 if(!isWasmInitialized) {
5322 throw new Error("initializeWasm() must be awaited first!");
5324 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
5325 return nativeResponseValue;
5327 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
5329 export function CResult__u832APIErrorZ_get_err(owner: bigint): bigint {
5330 if(!isWasmInitialized) {
5331 throw new Error("initializeWasm() must be awaited first!");
5333 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
5334 return nativeResponseValue;
5337 export class LDKRecentPaymentDetails {
5338 protected constructor() {}
5341 export function LDKRecentPaymentDetails_ty_from_ptr(ptr: bigint): number {
5342 if(!isWasmInitialized) {
5343 throw new Error("initializeWasm() must be awaited first!");
5345 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_ty_from_ptr(ptr);
5346 return nativeResponseValue;
5349 export function LDKRecentPaymentDetails_Pending_get_payment_hash(ptr: bigint): number {
5350 if(!isWasmInitialized) {
5351 throw new Error("initializeWasm() must be awaited first!");
5353 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
5354 return nativeResponseValue;
5357 export function LDKRecentPaymentDetails_Pending_get_total_msat(ptr: bigint): bigint {
5358 if(!isWasmInitialized) {
5359 throw new Error("initializeWasm() must be awaited first!");
5361 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
5362 return nativeResponseValue;
5365 export function LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr: bigint): bigint {
5366 if(!isWasmInitialized) {
5367 throw new Error("initializeWasm() must be awaited first!");
5369 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
5370 return nativeResponseValue;
5373 export function LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr: bigint): number {
5374 if(!isWasmInitialized) {
5375 throw new Error("initializeWasm() must be awaited first!");
5377 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
5378 return nativeResponseValue;
5381 export class LDKPaymentSendFailure {
5382 protected constructor() {}
5385 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
5386 if(!isWasmInitialized) {
5387 throw new Error("initializeWasm() must be awaited first!");
5389 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
5390 return nativeResponseValue;
5393 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
5394 if(!isWasmInitialized) {
5395 throw new Error("initializeWasm() must be awaited first!");
5397 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
5398 return nativeResponseValue;
5401 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
5402 if(!isWasmInitialized) {
5403 throw new Error("initializeWasm() must be awaited first!");
5405 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
5406 return nativeResponseValue;
5409 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
5410 if(!isWasmInitialized) {
5411 throw new Error("initializeWasm() must be awaited first!");
5413 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
5414 return nativeResponseValue;
5417 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
5418 if(!isWasmInitialized) {
5419 throw new Error("initializeWasm() must be awaited first!");
5421 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
5422 return nativeResponseValue;
5425 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
5426 if(!isWasmInitialized) {
5427 throw new Error("initializeWasm() must be awaited first!");
5429 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
5430 return nativeResponseValue;
5433 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
5434 if(!isWasmInitialized) {
5435 throw new Error("initializeWasm() must be awaited first!");
5437 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
5438 return nativeResponseValue;
5440 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
5442 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
5443 if(!isWasmInitialized) {
5444 throw new Error("initializeWasm() must be awaited first!");
5446 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
5447 // debug statements here
5449 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
5451 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
5452 if(!isWasmInitialized) {
5453 throw new Error("initializeWasm() must be awaited first!");
5455 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
5456 return nativeResponseValue;
5458 // void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
5460 export function CResult_NoneRetryableSendFailureZ_get_ok(owner: bigint): void {
5461 if(!isWasmInitialized) {
5462 throw new Error("initializeWasm() must be awaited first!");
5464 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_ok(owner);
5465 // debug statements here
5467 // enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
5469 export function CResult_NoneRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
5470 if(!isWasmInitialized) {
5471 throw new Error("initializeWasm() must be awaited first!");
5473 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_err(owner);
5474 return nativeResponseValue;
5476 // struct LDKThirtyTwoBytes CResult_PaymentHashPaymentSendFailureZ_get_ok(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner);
5478 export function CResult_PaymentHashPaymentSendFailureZ_get_ok(owner: bigint): number {
5479 if(!isWasmInitialized) {
5480 throw new Error("initializeWasm() must be awaited first!");
5482 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_get_ok(owner);
5483 return nativeResponseValue;
5485 // struct LDKPaymentSendFailure CResult_PaymentHashPaymentSendFailureZ_get_err(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner);
5487 export function CResult_PaymentHashPaymentSendFailureZ_get_err(owner: bigint): bigint {
5488 if(!isWasmInitialized) {
5489 throw new Error("initializeWasm() must be awaited first!");
5491 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_get_err(owner);
5492 return nativeResponseValue;
5494 // struct LDKThirtyTwoBytes CResult_PaymentHashRetryableSendFailureZ_get_ok(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner);
5496 export function CResult_PaymentHashRetryableSendFailureZ_get_ok(owner: bigint): number {
5497 if(!isWasmInitialized) {
5498 throw new Error("initializeWasm() must be awaited first!");
5500 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_get_ok(owner);
5501 return nativeResponseValue;
5503 // enum LDKRetryableSendFailure CResult_PaymentHashRetryableSendFailureZ_get_err(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner);
5505 export function CResult_PaymentHashRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
5506 if(!isWasmInitialized) {
5507 throw new Error("initializeWasm() must be awaited first!");
5509 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_get_err(owner);
5510 return nativeResponseValue;
5512 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
5514 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: bigint): number {
5515 if(!isWasmInitialized) {
5516 throw new Error("initializeWasm() must be awaited first!");
5518 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
5519 return nativeResponseValue;
5521 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
5523 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: bigint): number {
5524 if(!isWasmInitialized) {
5525 throw new Error("initializeWasm() must be awaited first!");
5527 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
5528 return nativeResponseValue;
5530 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
5532 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
5533 if(!isWasmInitialized) {
5534 throw new Error("initializeWasm() must be awaited first!");
5536 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
5537 return nativeResponseValue;
5539 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
5541 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: bigint): bigint {
5542 if(!isWasmInitialized) {
5543 throw new Error("initializeWasm() must be awaited first!");
5545 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
5546 return nativeResponseValue;
5548 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
5550 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: bigint): number {
5551 if(!isWasmInitialized) {
5552 throw new Error("initializeWasm() must be awaited first!");
5554 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
5555 return nativeResponseValue;
5557 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
5559 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: bigint): number {
5560 if(!isWasmInitialized) {
5561 throw new Error("initializeWasm() must be awaited first!");
5563 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
5564 return nativeResponseValue;
5566 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
5568 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: bigint): bigint {
5569 if(!isWasmInitialized) {
5570 throw new Error("initializeWasm() must be awaited first!");
5572 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
5573 return nativeResponseValue;
5575 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
5577 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: bigint): void {
5578 if(!isWasmInitialized) {
5579 throw new Error("initializeWasm() must be awaited first!");
5581 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
5582 // debug statements here
5584 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
5586 export function CResult_PaymentSecretNoneZ_get_ok(owner: bigint): number {
5587 if(!isWasmInitialized) {
5588 throw new Error("initializeWasm() must be awaited first!");
5590 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
5591 return nativeResponseValue;
5593 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
5595 export function CResult_PaymentSecretNoneZ_get_err(owner: bigint): void {
5596 if(!isWasmInitialized) {
5597 throw new Error("initializeWasm() must be awaited first!");
5599 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
5600 // debug statements here
5602 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
5604 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: bigint): number {
5605 if(!isWasmInitialized) {
5606 throw new Error("initializeWasm() must be awaited first!");
5608 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
5609 return nativeResponseValue;
5611 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
5613 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: bigint): bigint {
5614 if(!isWasmInitialized) {
5615 throw new Error("initializeWasm() must be awaited first!");
5617 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
5618 return nativeResponseValue;
5621 export class LDKCOption_CVec_ChainHashZZ {
5622 protected constructor() {}
5625 export function LDKCOption_CVec_ChainHashZZ_ty_from_ptr(ptr: bigint): number {
5626 if(!isWasmInitialized) {
5627 throw new Error("initializeWasm() must be awaited first!");
5629 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ChainHashZZ_ty_from_ptr(ptr);
5630 return nativeResponseValue;
5633 export function LDKCOption_CVec_ChainHashZZ_Some_get_some(ptr: bigint): number {
5634 if(!isWasmInitialized) {
5635 throw new Error("initializeWasm() must be awaited first!");
5637 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ChainHashZZ_Some_get_some(ptr);
5638 return nativeResponseValue;
5640 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
5642 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
5643 if(!isWasmInitialized) {
5644 throw new Error("initializeWasm() must be awaited first!");
5646 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
5647 return nativeResponseValue;
5649 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
5651 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
5652 if(!isWasmInitialized) {
5653 throw new Error("initializeWasm() must be awaited first!");
5655 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
5656 return nativeResponseValue;
5658 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
5660 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
5661 if(!isWasmInitialized) {
5662 throw new Error("initializeWasm() must be awaited first!");
5664 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
5665 return nativeResponseValue;
5667 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
5669 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
5670 if(!isWasmInitialized) {
5671 throw new Error("initializeWasm() must be awaited first!");
5673 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
5674 return nativeResponseValue;
5676 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
5678 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
5679 if(!isWasmInitialized) {
5680 throw new Error("initializeWasm() must be awaited first!");
5682 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
5683 return nativeResponseValue;
5685 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
5687 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
5688 if(!isWasmInitialized) {
5689 throw new Error("initializeWasm() must be awaited first!");
5691 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
5692 return nativeResponseValue;
5694 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
5696 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
5697 if(!isWasmInitialized) {
5698 throw new Error("initializeWasm() must be awaited first!");
5700 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
5701 return nativeResponseValue;
5703 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
5705 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
5706 if(!isWasmInitialized) {
5707 throw new Error("initializeWasm() must be awaited first!");
5709 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
5710 return nativeResponseValue;
5712 // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
5714 export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
5715 if(!isWasmInitialized) {
5716 throw new Error("initializeWasm() must be awaited first!");
5718 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
5719 return nativeResponseValue;
5721 // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
5723 export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
5724 if(!isWasmInitialized) {
5725 throw new Error("initializeWasm() must be awaited first!");
5727 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
5728 return nativeResponseValue;
5731 export interface LDKWatch {
5732 watch_channel (funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus;
5733 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
5734 release_pending_monitor_events (): number;
5738 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
5739 if(!isWasmInitialized) {
5740 throw new Error("initializeWasm() must be awaited first!");
5742 var new_obj_idx = js_objs.length;
5743 for (var i = 0; i < js_objs.length; i++) {
5744 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5746 js_objs[i] = new WeakRef(impl);
5747 return [wasm.TS_LDKWatch_new(i), i];
5749 // LDKChannelMonitorUpdateStatus Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
5751 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): ChannelMonitorUpdateStatus {
5752 if(!isWasmInitialized) {
5753 throw new Error("initializeWasm() must be awaited first!");
5755 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
5756 return nativeResponseValue;
5758 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update
5760 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
5761 if(!isWasmInitialized) {
5762 throw new Error("initializeWasm() must be awaited first!");
5764 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
5765 return nativeResponseValue;
5767 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
5769 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
5770 if(!isWasmInitialized) {
5771 throw new Error("initializeWasm() must be awaited first!");
5773 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
5774 return nativeResponseValue;
5777 export interface LDKBroadcasterInterface {
5778 broadcast_transactions (txs: number): void;
5782 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
5783 if(!isWasmInitialized) {
5784 throw new Error("initializeWasm() must be awaited first!");
5786 var new_obj_idx = js_objs.length;
5787 for (var i = 0; i < js_objs.length; i++) {
5788 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5790 js_objs[i] = new WeakRef(impl);
5791 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
5793 // void BroadcasterInterface_broadcast_transactions LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKCVec_TransactionZ txs
5795 export function BroadcasterInterface_broadcast_transactions(this_arg: bigint, txs: number): void {
5796 if(!isWasmInitialized) {
5797 throw new Error("initializeWasm() must be awaited first!");
5799 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transactions(this_arg, txs);
5800 // debug statements here
5803 export interface LDKEntropySource {
5804 get_secure_random_bytes (): number;
5808 export function LDKEntropySource_new(impl: LDKEntropySource): [bigint, number] {
5809 if(!isWasmInitialized) {
5810 throw new Error("initializeWasm() must be awaited first!");
5812 var new_obj_idx = js_objs.length;
5813 for (var i = 0; i < js_objs.length; i++) {
5814 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5816 js_objs[i] = new WeakRef(impl);
5817 return [wasm.TS_LDKEntropySource_new(i), i];
5819 // LDKThirtyTwoBytes EntropySource_get_secure_random_bytes LDKEntropySource *NONNULL_PTR this_arg
5821 export function EntropySource_get_secure_random_bytes(this_arg: bigint): number {
5822 if(!isWasmInitialized) {
5823 throw new Error("initializeWasm() must be awaited first!");
5825 const nativeResponseValue = wasm.TS_EntropySource_get_secure_random_bytes(this_arg);
5826 return nativeResponseValue;
5829 export class LDKUnsignedGossipMessage {
5830 protected constructor() {}
5833 export function LDKUnsignedGossipMessage_ty_from_ptr(ptr: bigint): number {
5834 if(!isWasmInitialized) {
5835 throw new Error("initializeWasm() must be awaited first!");
5837 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ty_from_ptr(ptr);
5838 return nativeResponseValue;
5841 export function LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr: bigint): bigint {
5842 if(!isWasmInitialized) {
5843 throw new Error("initializeWasm() must be awaited first!");
5845 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr);
5846 return nativeResponseValue;
5849 export function LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr: bigint): bigint {
5850 if(!isWasmInitialized) {
5851 throw new Error("initializeWasm() must be awaited first!");
5853 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr);
5854 return nativeResponseValue;
5857 export function LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr: bigint): bigint {
5858 if(!isWasmInitialized) {
5859 throw new Error("initializeWasm() must be awaited first!");
5861 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr);
5862 return nativeResponseValue;
5865 export interface LDKNodeSigner {
5866 get_inbound_payment_key_material (): number;
5867 get_node_id (recipient: Recipient): bigint;
5868 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
5869 sign_invoice (hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint;
5870 sign_gossip_message (msg: bigint): bigint;
5874 export function LDKNodeSigner_new(impl: LDKNodeSigner): [bigint, number] {
5875 if(!isWasmInitialized) {
5876 throw new Error("initializeWasm() must be awaited first!");
5878 var new_obj_idx = js_objs.length;
5879 for (var i = 0; i < js_objs.length; i++) {
5880 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5882 js_objs[i] = new WeakRef(impl);
5883 return [wasm.TS_LDKNodeSigner_new(i), i];
5885 // LDKThirtyTwoBytes NodeSigner_get_inbound_payment_key_material LDKNodeSigner *NONNULL_PTR this_arg
5887 export function NodeSigner_get_inbound_payment_key_material(this_arg: bigint): number {
5888 if(!isWasmInitialized) {
5889 throw new Error("initializeWasm() must be awaited first!");
5891 const nativeResponseValue = wasm.TS_NodeSigner_get_inbound_payment_key_material(this_arg);
5892 return nativeResponseValue;
5894 // LDKCResult_PublicKeyNoneZ NodeSigner_get_node_id LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient
5896 export function NodeSigner_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
5897 if(!isWasmInitialized) {
5898 throw new Error("initializeWasm() must be awaited first!");
5900 const nativeResponseValue = wasm.TS_NodeSigner_get_node_id(this_arg, recipient);
5901 return nativeResponseValue;
5903 // LDKCResult_SharedSecretNoneZ NodeSigner_ecdh LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak
5905 export function NodeSigner_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
5906 if(!isWasmInitialized) {
5907 throw new Error("initializeWasm() must be awaited first!");
5909 const nativeResponseValue = wasm.TS_NodeSigner_ecdh(this_arg, recipient, other_key, tweak);
5910 return nativeResponseValue;
5912 // LDKCResult_RecoverableSignatureNoneZ NodeSigner_sign_invoice LDKNodeSigner *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient
5914 export function NodeSigner_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint {
5915 if(!isWasmInitialized) {
5916 throw new Error("initializeWasm() must be awaited first!");
5918 const nativeResponseValue = wasm.TS_NodeSigner_sign_invoice(this_arg, hrp_bytes, invoice_data, recipient);
5919 return nativeResponseValue;
5921 // LDKCResult_SignatureNoneZ NodeSigner_sign_gossip_message LDKNodeSigner *NONNULL_PTR this_arg, struct LDKUnsignedGossipMessage msg
5923 export function NodeSigner_sign_gossip_message(this_arg: bigint, msg: bigint): bigint {
5924 if(!isWasmInitialized) {
5925 throw new Error("initializeWasm() must be awaited first!");
5927 const nativeResponseValue = wasm.TS_NodeSigner_sign_gossip_message(this_arg, msg);
5928 return nativeResponseValue;
5931 export interface LDKSignerProvider {
5932 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
5933 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
5934 read_chan_signer (reader: number): bigint;
5935 get_destination_script (): bigint;
5936 get_shutdown_scriptpubkey (): bigint;
5940 export function LDKSignerProvider_new(impl: LDKSignerProvider): [bigint, number] {
5941 if(!isWasmInitialized) {
5942 throw new Error("initializeWasm() must be awaited first!");
5944 var new_obj_idx = js_objs.length;
5945 for (var i = 0; i < js_objs.length; i++) {
5946 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5948 js_objs[i] = new WeakRef(impl);
5949 return [wasm.TS_LDKSignerProvider_new(i), i];
5951 // LDKThirtyTwoBytes SignerProvider_generate_channel_keys_id LDKSignerProvider *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
5953 export function SignerProvider_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
5954 if(!isWasmInitialized) {
5955 throw new Error("initializeWasm() must be awaited first!");
5957 const nativeResponseValue = wasm.TS_SignerProvider_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
5958 return nativeResponseValue;
5960 // LDKWriteableEcdsaChannelSigner SignerProvider_derive_channel_signer LDKSignerProvider *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
5962 export function SignerProvider_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
5963 if(!isWasmInitialized) {
5964 throw new Error("initializeWasm() must be awaited first!");
5966 const nativeResponseValue = wasm.TS_SignerProvider_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
5967 return nativeResponseValue;
5969 // LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider_read_chan_signer LDKSignerProvider *NONNULL_PTR this_arg, struct LDKu8slice reader
5971 export function SignerProvider_read_chan_signer(this_arg: bigint, reader: number): bigint {
5972 if(!isWasmInitialized) {
5973 throw new Error("initializeWasm() must be awaited first!");
5975 const nativeResponseValue = wasm.TS_SignerProvider_read_chan_signer(this_arg, reader);
5976 return nativeResponseValue;
5978 // LDKCResult_ScriptNoneZ SignerProvider_get_destination_script LDKSignerProvider *NONNULL_PTR this_arg
5980 export function SignerProvider_get_destination_script(this_arg: bigint): bigint {
5981 if(!isWasmInitialized) {
5982 throw new Error("initializeWasm() must be awaited first!");
5984 const nativeResponseValue = wasm.TS_SignerProvider_get_destination_script(this_arg);
5985 return nativeResponseValue;
5987 // LDKCResult_ShutdownScriptNoneZ SignerProvider_get_shutdown_scriptpubkey LDKSignerProvider *NONNULL_PTR this_arg
5989 export function SignerProvider_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
5990 if(!isWasmInitialized) {
5991 throw new Error("initializeWasm() must be awaited first!");
5993 const nativeResponseValue = wasm.TS_SignerProvider_get_shutdown_scriptpubkey(this_arg);
5994 return nativeResponseValue;
5997 export interface LDKFeeEstimator {
5998 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
6002 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
6003 if(!isWasmInitialized) {
6004 throw new Error("initializeWasm() must be awaited first!");
6006 var new_obj_idx = js_objs.length;
6007 for (var i = 0; i < js_objs.length; i++) {
6008 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6010 js_objs[i] = new WeakRef(impl);
6011 return [wasm.TS_LDKFeeEstimator_new(i), i];
6013 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
6015 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
6016 if(!isWasmInitialized) {
6017 throw new Error("initializeWasm() must be awaited first!");
6019 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
6020 return nativeResponseValue;
6023 export interface LDKRouter {
6024 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
6025 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
6029 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
6030 if(!isWasmInitialized) {
6031 throw new Error("initializeWasm() must be awaited first!");
6033 var new_obj_idx = js_objs.length;
6034 for (var i = 0; i < js_objs.length; i++) {
6035 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6037 js_objs[i] = new WeakRef(impl);
6038 return [wasm.TS_LDKRouter_new(i), i];
6040 // 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, struct LDKInFlightHtlcs inflight_htlcs
6042 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
6043 if(!isWasmInitialized) {
6044 throw new Error("initializeWasm() must be awaited first!");
6046 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
6047 return nativeResponseValue;
6049 // 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, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id
6051 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 {
6052 if(!isWasmInitialized) {
6053 throw new Error("initializeWasm() must be awaited first!");
6055 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
6056 return nativeResponseValue;
6058 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
6060 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: bigint): number {
6061 if(!isWasmInitialized) {
6062 throw new Error("initializeWasm() must be awaited first!");
6064 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
6065 return nativeResponseValue;
6067 // struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
6069 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: bigint): bigint {
6070 if(!isWasmInitialized) {
6071 throw new Error("initializeWasm() must be awaited first!");
6073 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
6074 return nativeResponseValue;
6076 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
6078 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
6079 if(!isWasmInitialized) {
6080 throw new Error("initializeWasm() must be awaited first!");
6082 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
6083 return nativeResponseValue;
6085 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
6087 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
6088 if(!isWasmInitialized) {
6089 throw new Error("initializeWasm() must be awaited first!");
6091 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
6092 return nativeResponseValue;
6095 export class LDKMaxDustHTLCExposure {
6096 protected constructor() {}
6099 export function LDKMaxDustHTLCExposure_ty_from_ptr(ptr: bigint): number {
6100 if(!isWasmInitialized) {
6101 throw new Error("initializeWasm() must be awaited first!");
6103 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_ty_from_ptr(ptr);
6104 return nativeResponseValue;
6107 export function LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr: bigint): bigint {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr);
6112 return nativeResponseValue;
6115 export function LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr: bigint): bigint {
6116 if(!isWasmInitialized) {
6117 throw new Error("initializeWasm() must be awaited first!");
6119 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr);
6120 return nativeResponseValue;
6122 // struct LDKMaxDustHTLCExposure CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
6124 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner: bigint): bigint {
6125 if(!isWasmInitialized) {
6126 throw new Error("initializeWasm() must be awaited first!");
6128 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner);
6129 return nativeResponseValue;
6131 // struct LDKDecodeError CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
6133 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner: bigint): bigint {
6134 if(!isWasmInitialized) {
6135 throw new Error("initializeWasm() must be awaited first!");
6137 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner);
6138 return nativeResponseValue;
6140 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
6142 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
6143 if(!isWasmInitialized) {
6144 throw new Error("initializeWasm() must be awaited first!");
6146 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
6147 return nativeResponseValue;
6149 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
6151 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
6152 if(!isWasmInitialized) {
6153 throw new Error("initializeWasm() must be awaited first!");
6155 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
6156 return nativeResponseValue;
6159 export class LDKCOption_MaxDustHTLCExposureZ {
6160 protected constructor() {}
6163 export function LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr: bigint): number {
6164 if(!isWasmInitialized) {
6165 throw new Error("initializeWasm() must be awaited first!");
6167 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr);
6168 return nativeResponseValue;
6171 export function LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr: bigint): bigint {
6172 if(!isWasmInitialized) {
6173 throw new Error("initializeWasm() must be awaited first!");
6175 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr);
6176 return nativeResponseValue;
6179 export class LDKCOption_APIErrorZ {
6180 protected constructor() {}
6183 export function LDKCOption_APIErrorZ_ty_from_ptr(ptr: bigint): number {
6184 if(!isWasmInitialized) {
6185 throw new Error("initializeWasm() must be awaited first!");
6187 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_ty_from_ptr(ptr);
6188 return nativeResponseValue;
6191 export function LDKCOption_APIErrorZ_Some_get_some(ptr: bigint): bigint {
6192 if(!isWasmInitialized) {
6193 throw new Error("initializeWasm() must be awaited first!");
6195 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_Some_get_some(ptr);
6196 return nativeResponseValue;
6198 // struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
6200 export function CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner: bigint): bigint {
6201 if(!isWasmInitialized) {
6202 throw new Error("initializeWasm() must be awaited first!");
6204 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner);
6205 return nativeResponseValue;
6207 // struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
6209 export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bigint {
6210 if(!isWasmInitialized) {
6211 throw new Error("initializeWasm() must be awaited first!");
6213 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
6214 return nativeResponseValue;
6216 // struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
6218 export function CResult_BigSizeDecodeErrorZ_get_ok(owner: bigint): bigint {
6219 if(!isWasmInitialized) {
6220 throw new Error("initializeWasm() must be awaited first!");
6222 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_ok(owner);
6223 return nativeResponseValue;
6225 // struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
6227 export function CResult_BigSizeDecodeErrorZ_get_err(owner: bigint): bigint {
6228 if(!isWasmInitialized) {
6229 throw new Error("initializeWasm() must be awaited first!");
6231 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_err(owner);
6232 return nativeResponseValue;
6234 // struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
6236 export function CResult_HostnameDecodeErrorZ_get_ok(owner: bigint): bigint {
6237 if(!isWasmInitialized) {
6238 throw new Error("initializeWasm() must be awaited first!");
6240 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_ok(owner);
6241 return nativeResponseValue;
6243 // struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
6245 export function CResult_HostnameDecodeErrorZ_get_err(owner: bigint): bigint {
6246 if(!isWasmInitialized) {
6247 throw new Error("initializeWasm() must be awaited first!");
6249 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_err(owner);
6250 return nativeResponseValue;
6252 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
6254 export function CResult_TransactionU16LenLimitedNoneZ_get_ok(owner: bigint): bigint {
6255 if(!isWasmInitialized) {
6256 throw new Error("initializeWasm() must be awaited first!");
6258 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_ok(owner);
6259 return nativeResponseValue;
6261 // void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
6263 export function CResult_TransactionU16LenLimitedNoneZ_get_err(owner: bigint): void {
6264 if(!isWasmInitialized) {
6265 throw new Error("initializeWasm() must be awaited first!");
6267 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_err(owner);
6268 // debug statements here
6270 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
6272 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner: bigint): bigint {
6273 if(!isWasmInitialized) {
6274 throw new Error("initializeWasm() must be awaited first!");
6276 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner);
6277 return nativeResponseValue;
6279 // struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
6281 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner: bigint): bigint {
6282 if(!isWasmInitialized) {
6283 throw new Error("initializeWasm() must be awaited first!");
6285 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner);
6286 return nativeResponseValue;
6288 // struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
6290 export function CResult_UntrustedStringDecodeErrorZ_get_ok(owner: bigint): bigint {
6291 if(!isWasmInitialized) {
6292 throw new Error("initializeWasm() must be awaited first!");
6294 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_ok(owner);
6295 return nativeResponseValue;
6297 // struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
6299 export function CResult_UntrustedStringDecodeErrorZ_get_err(owner: bigint): bigint {
6300 if(!isWasmInitialized) {
6301 throw new Error("initializeWasm() must be awaited first!");
6303 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_err(owner);
6304 return nativeResponseValue;
6306 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
6308 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
6309 if(!isWasmInitialized) {
6310 throw new Error("initializeWasm() must be awaited first!");
6312 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
6313 return nativeResponseValue;
6315 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
6317 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
6318 if(!isWasmInitialized) {
6319 throw new Error("initializeWasm() must be awaited first!");
6321 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
6322 return nativeResponseValue;
6325 export interface LDKType {
6327 debug_str (): number;
6332 export function LDKType_new(impl: LDKType): [bigint, number] {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 var new_obj_idx = js_objs.length;
6337 for (var i = 0; i < js_objs.length; i++) {
6338 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6340 js_objs[i] = new WeakRef(impl);
6341 return [wasm.TS_LDKType_new(i), i];
6343 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
6345 export function Type_type_id(this_arg: bigint): number {
6346 if(!isWasmInitialized) {
6347 throw new Error("initializeWasm() must be awaited first!");
6349 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
6350 return nativeResponseValue;
6352 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
6354 export function Type_debug_str(this_arg: bigint): number {
6355 if(!isWasmInitialized) {
6356 throw new Error("initializeWasm() must be awaited first!");
6358 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
6359 return nativeResponseValue;
6361 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
6363 export function Type_write(this_arg: bigint): number {
6364 if(!isWasmInitialized) {
6365 throw new Error("initializeWasm() must be awaited first!");
6367 const nativeResponseValue = wasm.TS_Type_write(this_arg);
6368 return nativeResponseValue;
6371 export class LDKCOption_TypeZ {
6372 protected constructor() {}
6375 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
6376 if(!isWasmInitialized) {
6377 throw new Error("initializeWasm() must be awaited first!");
6379 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
6380 return nativeResponseValue;
6383 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
6384 if(!isWasmInitialized) {
6385 throw new Error("initializeWasm() must be awaited first!");
6387 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
6388 return nativeResponseValue;
6390 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
6392 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
6393 if(!isWasmInitialized) {
6394 throw new Error("initializeWasm() must be awaited first!");
6396 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
6397 return nativeResponseValue;
6399 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
6401 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
6402 if(!isWasmInitialized) {
6403 throw new Error("initializeWasm() must be awaited first!");
6405 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
6406 return nativeResponseValue;
6409 export class LDKPaymentError {
6410 protected constructor() {}
6413 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
6418 return nativeResponseValue;
6421 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
6422 if(!isWasmInitialized) {
6423 throw new Error("initializeWasm() must be awaited first!");
6425 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
6426 return nativeResponseValue;
6429 export function LDKPaymentError_Sending_get_sending(ptr: bigint): RetryableSendFailure {
6430 if(!isWasmInitialized) {
6431 throw new Error("initializeWasm() must be awaited first!");
6433 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
6434 return nativeResponseValue;
6436 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
6438 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: bigint): number {
6439 if(!isWasmInitialized) {
6440 throw new Error("initializeWasm() must be awaited first!");
6442 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
6443 return nativeResponseValue;
6445 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
6447 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: bigint): bigint {
6448 if(!isWasmInitialized) {
6449 throw new Error("initializeWasm() must be awaited first!");
6451 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
6452 return nativeResponseValue;
6454 // void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
6456 export function CResult_NonePaymentErrorZ_get_ok(owner: bigint): void {
6457 if(!isWasmInitialized) {
6458 throw new Error("initializeWasm() must be awaited first!");
6460 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_ok(owner);
6461 // debug statements here
6463 // struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
6465 export function CResult_NonePaymentErrorZ_get_err(owner: bigint): bigint {
6466 if(!isWasmInitialized) {
6467 throw new Error("initializeWasm() must be awaited first!");
6469 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_err(owner);
6470 return nativeResponseValue;
6472 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
6474 export function CResult_StringErrorZ_get_ok(owner: bigint): number {
6475 if(!isWasmInitialized) {
6476 throw new Error("initializeWasm() must be awaited first!");
6478 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
6479 return nativeResponseValue;
6481 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
6483 export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
6484 if(!isWasmInitialized) {
6485 throw new Error("initializeWasm() must be awaited first!");
6487 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
6488 return nativeResponseValue;
6490 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
6492 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6493 if(!isWasmInitialized) {
6494 throw new Error("initializeWasm() must be awaited first!");
6496 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
6497 return nativeResponseValue;
6499 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
6501 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6502 if(!isWasmInitialized) {
6503 throw new Error("initializeWasm() must be awaited first!");
6505 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
6506 return nativeResponseValue;
6509 export class LDKCOption_MonitorEventZ {
6510 protected constructor() {}
6513 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
6514 if(!isWasmInitialized) {
6515 throw new Error("initializeWasm() must be awaited first!");
6517 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
6518 return nativeResponseValue;
6521 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
6526 return nativeResponseValue;
6528 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
6530 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
6535 return nativeResponseValue;
6537 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
6539 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
6544 return nativeResponseValue;
6546 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
6548 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
6553 return nativeResponseValue;
6555 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
6557 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
6562 return nativeResponseValue;
6564 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
6566 export function C2Tuple_OutPointScriptZ_get_a(owner: bigint): bigint {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
6571 return nativeResponseValue;
6573 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
6575 export function C2Tuple_OutPointScriptZ_get_b(owner: bigint): number {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
6580 return nativeResponseValue;
6582 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
6584 export function C2Tuple_u32ScriptZ_get_a(owner: bigint): number {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
6589 return nativeResponseValue;
6591 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
6593 export function C2Tuple_u32ScriptZ_get_b(owner: bigint): number {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
6598 return nativeResponseValue;
6600 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
6602 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: bigint): number {
6603 if(!isWasmInitialized) {
6604 throw new Error("initializeWasm() must be awaited first!");
6606 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
6607 return nativeResponseValue;
6609 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
6611 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: bigint): number {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
6616 return nativeResponseValue;
6618 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
6620 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
6621 if(!isWasmInitialized) {
6622 throw new Error("initializeWasm() must be awaited first!");
6624 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
6625 return nativeResponseValue;
6627 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
6629 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
6630 if(!isWasmInitialized) {
6631 throw new Error("initializeWasm() must be awaited first!");
6633 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
6634 return nativeResponseValue;
6636 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
6638 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
6639 if(!isWasmInitialized) {
6640 throw new Error("initializeWasm() must be awaited first!");
6642 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
6643 return nativeResponseValue;
6645 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
6647 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
6648 if(!isWasmInitialized) {
6649 throw new Error("initializeWasm() must be awaited first!");
6651 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
6652 return nativeResponseValue;
6655 export class LDKBalance {
6656 protected constructor() {}
6659 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
6660 if(!isWasmInitialized) {
6661 throw new Error("initializeWasm() must be awaited first!");
6663 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
6664 return nativeResponseValue;
6667 export function LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr: bigint): bigint {
6668 if(!isWasmInitialized) {
6669 throw new Error("initializeWasm() must be awaited first!");
6671 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr);
6672 return nativeResponseValue;
6675 export function LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr: bigint): bigint {
6676 if(!isWasmInitialized) {
6677 throw new Error("initializeWasm() must be awaited first!");
6679 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr);
6680 return nativeResponseValue;
6683 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
6684 if(!isWasmInitialized) {
6685 throw new Error("initializeWasm() must be awaited first!");
6687 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
6688 return nativeResponseValue;
6691 export function LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr: bigint): bigint {
6692 if(!isWasmInitialized) {
6693 throw new Error("initializeWasm() must be awaited first!");
6695 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr);
6696 return nativeResponseValue;
6699 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
6700 if(!isWasmInitialized) {
6701 throw new Error("initializeWasm() must be awaited first!");
6703 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
6704 return nativeResponseValue;
6707 export function LDKBalance_ContentiousClaimable_get_payment_hash(ptr: bigint): number {
6708 if(!isWasmInitialized) {
6709 throw new Error("initializeWasm() must be awaited first!");
6711 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_hash(ptr);
6712 return nativeResponseValue;
6715 export function LDKBalance_ContentiousClaimable_get_payment_preimage(ptr: bigint): number {
6716 if(!isWasmInitialized) {
6717 throw new Error("initializeWasm() must be awaited first!");
6719 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_preimage(ptr);
6720 return nativeResponseValue;
6723 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
6724 if(!isWasmInitialized) {
6725 throw new Error("initializeWasm() must be awaited first!");
6727 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr);
6728 return nativeResponseValue;
6731 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
6732 if(!isWasmInitialized) {
6733 throw new Error("initializeWasm() must be awaited first!");
6735 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
6736 return nativeResponseValue;
6739 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr: bigint): number {
6740 if(!isWasmInitialized) {
6741 throw new Error("initializeWasm() must be awaited first!");
6743 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr);
6744 return nativeResponseValue;
6747 export function LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
6748 if(!isWasmInitialized) {
6749 throw new Error("initializeWasm() must be awaited first!");
6751 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr);
6752 return nativeResponseValue;
6755 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
6756 if(!isWasmInitialized) {
6757 throw new Error("initializeWasm() must be awaited first!");
6759 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
6760 return nativeResponseValue;
6763 export function LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr: bigint): number {
6764 if(!isWasmInitialized) {
6765 throw new Error("initializeWasm() must be awaited first!");
6767 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr);
6768 return nativeResponseValue;
6771 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr: bigint): bigint {
6772 if(!isWasmInitialized) {
6773 throw new Error("initializeWasm() must be awaited first!");
6775 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr);
6776 return nativeResponseValue;
6778 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
6780 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: bigint): number {
6781 if(!isWasmInitialized) {
6782 throw new Error("initializeWasm() must be awaited first!");
6784 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
6785 return nativeResponseValue;
6787 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
6789 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: bigint): bigint {
6790 if(!isWasmInitialized) {
6791 throw new Error("initializeWasm() must be awaited first!");
6793 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
6794 return nativeResponseValue;
6796 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
6798 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
6799 if(!isWasmInitialized) {
6800 throw new Error("initializeWasm() must be awaited first!");
6802 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
6803 return nativeResponseValue;
6805 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
6807 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
6808 if(!isWasmInitialized) {
6809 throw new Error("initializeWasm() must be awaited first!");
6811 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
6812 return nativeResponseValue;
6814 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
6816 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
6817 if(!isWasmInitialized) {
6818 throw new Error("initializeWasm() must be awaited first!");
6820 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
6821 return nativeResponseValue;
6823 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
6825 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
6826 if(!isWasmInitialized) {
6827 throw new Error("initializeWasm() must be awaited first!");
6829 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
6830 return nativeResponseValue;
6833 export interface LDKCustomOnionMessageContents {
6834 tlv_type (): bigint;
6839 export function LDKCustomOnionMessageContents_new(impl: LDKCustomOnionMessageContents): [bigint, number] {
6840 if(!isWasmInitialized) {
6841 throw new Error("initializeWasm() must be awaited first!");
6843 var new_obj_idx = js_objs.length;
6844 for (var i = 0; i < js_objs.length; i++) {
6845 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6847 js_objs[i] = new WeakRef(impl);
6848 return [wasm.TS_LDKCustomOnionMessageContents_new(i), i];
6850 // uint64_t CustomOnionMessageContents_tlv_type LDKCustomOnionMessageContents *NONNULL_PTR this_arg
6852 export function CustomOnionMessageContents_tlv_type(this_arg: bigint): bigint {
6853 if(!isWasmInitialized) {
6854 throw new Error("initializeWasm() must be awaited first!");
6856 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_tlv_type(this_arg);
6857 return nativeResponseValue;
6859 // LDKCVec_u8Z CustomOnionMessageContents_write LDKCustomOnionMessageContents *NONNULL_PTR this_arg
6861 export function CustomOnionMessageContents_write(this_arg: bigint): number {
6862 if(!isWasmInitialized) {
6863 throw new Error("initializeWasm() must be awaited first!");
6865 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_write(this_arg);
6866 return nativeResponseValue;
6869 export class LDKCOption_CustomOnionMessageContentsZ {
6870 protected constructor() {}
6873 export function LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
6874 if(!isWasmInitialized) {
6875 throw new Error("initializeWasm() must be awaited first!");
6877 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr);
6878 return nativeResponseValue;
6881 export function LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
6882 if(!isWasmInitialized) {
6883 throw new Error("initializeWasm() must be awaited first!");
6885 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr);
6886 return nativeResponseValue;
6888 // struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
6890 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
6891 if(!isWasmInitialized) {
6892 throw new Error("initializeWasm() must be awaited first!");
6894 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner);
6895 return nativeResponseValue;
6897 // struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
6899 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
6900 if(!isWasmInitialized) {
6901 throw new Error("initializeWasm() must be awaited first!");
6903 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner);
6904 return nativeResponseValue;
6907 export class LDKCOption_NetAddressZ {
6908 protected constructor() {}
6911 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: bigint): number {
6912 if(!isWasmInitialized) {
6913 throw new Error("initializeWasm() must be awaited first!");
6915 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
6916 return nativeResponseValue;
6919 export function LDKCOption_NetAddressZ_Some_get_some(ptr: bigint): bigint {
6920 if(!isWasmInitialized) {
6921 throw new Error("initializeWasm() must be awaited first!");
6923 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
6924 return nativeResponseValue;
6926 // struct LDKPublicKey C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner);
6928 export function C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(owner: bigint): number {
6929 if(!isWasmInitialized) {
6930 throw new Error("initializeWasm() must be awaited first!");
6932 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(owner);
6933 return nativeResponseValue;
6935 // struct LDKCOption_NetAddressZ C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner);
6937 export function C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(owner: bigint): bigint {
6938 if(!isWasmInitialized) {
6939 throw new Error("initializeWasm() must be awaited first!");
6941 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(owner);
6942 return nativeResponseValue;
6944 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
6946 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
6947 if(!isWasmInitialized) {
6948 throw new Error("initializeWasm() must be awaited first!");
6950 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
6951 return nativeResponseValue;
6953 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
6955 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
6956 if(!isWasmInitialized) {
6957 throw new Error("initializeWasm() must be awaited first!");
6959 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
6960 return nativeResponseValue;
6962 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
6964 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
6965 if(!isWasmInitialized) {
6966 throw new Error("initializeWasm() must be awaited first!");
6968 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
6969 // debug statements here
6971 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
6973 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
6974 if(!isWasmInitialized) {
6975 throw new Error("initializeWasm() must be awaited first!");
6977 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
6978 return nativeResponseValue;
6980 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
6982 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
6983 if(!isWasmInitialized) {
6984 throw new Error("initializeWasm() must be awaited first!");
6986 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
6987 return nativeResponseValue;
6989 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
6991 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
6992 if(!isWasmInitialized) {
6993 throw new Error("initializeWasm() must be awaited first!");
6995 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
6996 return nativeResponseValue;
6998 // struct LDKOnionMessagePath CResult_OnionMessagePathNoneZ_get_ok(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
7000 export function CResult_OnionMessagePathNoneZ_get_ok(owner: bigint): bigint {
7001 if(!isWasmInitialized) {
7002 throw new Error("initializeWasm() must be awaited first!");
7004 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_ok(owner);
7005 return nativeResponseValue;
7007 // void CResult_OnionMessagePathNoneZ_get_err(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
7009 export function CResult_OnionMessagePathNoneZ_get_err(owner: bigint): void {
7010 if(!isWasmInitialized) {
7011 throw new Error("initializeWasm() must be awaited first!");
7013 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_err(owner);
7014 // debug statements here
7017 export class LDKSendError {
7018 protected constructor() {}
7021 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
7022 if(!isWasmInitialized) {
7023 throw new Error("initializeWasm() must be awaited first!");
7025 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
7026 return nativeResponseValue;
7029 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
7030 if(!isWasmInitialized) {
7031 throw new Error("initializeWasm() must be awaited first!");
7033 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
7034 return nativeResponseValue;
7036 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
7038 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
7039 if(!isWasmInitialized) {
7040 throw new Error("initializeWasm() must be awaited first!");
7042 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
7043 // debug statements here
7045 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
7047 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
7048 if(!isWasmInitialized) {
7049 throw new Error("initializeWasm() must be awaited first!");
7051 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
7052 return nativeResponseValue;
7054 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
7056 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
7057 if(!isWasmInitialized) {
7058 throw new Error("initializeWasm() must be awaited first!");
7060 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
7061 return nativeResponseValue;
7063 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
7065 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
7066 if(!isWasmInitialized) {
7067 throw new Error("initializeWasm() must be awaited first!");
7069 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
7070 // debug statements here
7072 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
7074 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
7075 if(!isWasmInitialized) {
7076 throw new Error("initializeWasm() must be awaited first!");
7078 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
7079 return nativeResponseValue;
7081 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
7083 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
7084 if(!isWasmInitialized) {
7085 throw new Error("initializeWasm() must be awaited first!");
7087 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
7088 return nativeResponseValue;
7090 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
7092 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
7093 if(!isWasmInitialized) {
7094 throw new Error("initializeWasm() must be awaited first!");
7096 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
7097 return nativeResponseValue;
7099 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
7101 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
7102 if(!isWasmInitialized) {
7103 throw new Error("initializeWasm() must be awaited first!");
7105 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
7106 return nativeResponseValue;
7109 export class LDKGraphSyncError {
7110 protected constructor() {}
7113 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
7114 if(!isWasmInitialized) {
7115 throw new Error("initializeWasm() must be awaited first!");
7117 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
7118 return nativeResponseValue;
7121 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
7122 if(!isWasmInitialized) {
7123 throw new Error("initializeWasm() must be awaited first!");
7125 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
7126 return nativeResponseValue;
7129 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
7130 if(!isWasmInitialized) {
7131 throw new Error("initializeWasm() must be awaited first!");
7133 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
7134 return nativeResponseValue;
7136 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
7138 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
7139 if(!isWasmInitialized) {
7140 throw new Error("initializeWasm() must be awaited first!");
7142 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
7143 return nativeResponseValue;
7145 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
7147 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
7148 if(!isWasmInitialized) {
7149 throw new Error("initializeWasm() must be awaited first!");
7151 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
7152 return nativeResponseValue;
7154 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
7156 export function CResult_NoneErrorZ_get_ok(owner: bigint): void {
7157 if(!isWasmInitialized) {
7158 throw new Error("initializeWasm() must be awaited first!");
7160 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
7161 // debug statements here
7163 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
7165 export function CResult_NoneErrorZ_get_err(owner: bigint): IOError {
7166 if(!isWasmInitialized) {
7167 throw new Error("initializeWasm() must be awaited first!");
7169 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
7170 return nativeResponseValue;
7173 export class LDKCOption_ScriptZ {
7174 protected constructor() {}
7177 export function LDKCOption_ScriptZ_ty_from_ptr(ptr: bigint): number {
7178 if(!isWasmInitialized) {
7179 throw new Error("initializeWasm() must be awaited first!");
7181 const nativeResponseValue = wasm.TS_LDKCOption_ScriptZ_ty_from_ptr(ptr);
7182 return nativeResponseValue;
7185 export function LDKCOption_ScriptZ_Some_get_some(ptr: bigint): number {
7186 if(!isWasmInitialized) {
7187 throw new Error("initializeWasm() must be awaited first!");
7189 const nativeResponseValue = wasm.TS_LDKCOption_ScriptZ_Some_get_some(ptr);
7190 return nativeResponseValue;
7193 export class LDKCOption_i64Z {
7194 protected constructor() {}
7197 export function LDKCOption_i64Z_ty_from_ptr(ptr: bigint): number {
7198 if(!isWasmInitialized) {
7199 throw new Error("initializeWasm() must be awaited first!");
7201 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_ty_from_ptr(ptr);
7202 return nativeResponseValue;
7205 export function LDKCOption_i64Z_Some_get_some(ptr: bigint): bigint {
7206 if(!isWasmInitialized) {
7207 throw new Error("initializeWasm() must be awaited first!");
7209 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_Some_get_some(ptr);
7210 return nativeResponseValue;
7213 export class LDKCOption_TxidZ {
7214 protected constructor() {}
7217 export function LDKCOption_TxidZ_ty_from_ptr(ptr: bigint): number {
7218 if(!isWasmInitialized) {
7219 throw new Error("initializeWasm() must be awaited first!");
7221 const nativeResponseValue = wasm.TS_LDKCOption_TxidZ_ty_from_ptr(ptr);
7222 return nativeResponseValue;
7225 export function LDKCOption_TxidZ_Some_get_some(ptr: bigint): number {
7226 if(!isWasmInitialized) {
7227 throw new Error("initializeWasm() must be awaited first!");
7229 const nativeResponseValue = wasm.TS_LDKCOption_TxidZ_Some_get_some(ptr);
7230 return nativeResponseValue;
7232 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
7234 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
7235 if(!isWasmInitialized) {
7236 throw new Error("initializeWasm() must be awaited first!");
7238 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
7239 return nativeResponseValue;
7241 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
7243 export function CResult_NetAddressDecodeErrorZ_get_err(owner: bigint): bigint {
7244 if(!isWasmInitialized) {
7245 throw new Error("initializeWasm() must be awaited first!");
7247 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
7248 return nativeResponseValue;
7250 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
7252 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
7253 if(!isWasmInitialized) {
7254 throw new Error("initializeWasm() must be awaited first!");
7256 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
7257 return nativeResponseValue;
7259 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
7261 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
7262 if(!isWasmInitialized) {
7263 throw new Error("initializeWasm() must be awaited first!");
7265 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
7266 return nativeResponseValue;
7268 // struct LDKAcceptChannelV2 CResult_AcceptChannelV2DecodeErrorZ_get_ok(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
7270 export function CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
7271 if(!isWasmInitialized) {
7272 throw new Error("initializeWasm() must be awaited first!");
7274 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner);
7275 return nativeResponseValue;
7277 // struct LDKDecodeError CResult_AcceptChannelV2DecodeErrorZ_get_err(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
7279 export function CResult_AcceptChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
7280 if(!isWasmInitialized) {
7281 throw new Error("initializeWasm() must be awaited first!");
7283 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_err(owner);
7284 return nativeResponseValue;
7286 // struct LDKTxAddInput CResult_TxAddInputDecodeErrorZ_get_ok(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
7288 export function CResult_TxAddInputDecodeErrorZ_get_ok(owner: bigint): bigint {
7289 if(!isWasmInitialized) {
7290 throw new Error("initializeWasm() must be awaited first!");
7292 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_ok(owner);
7293 return nativeResponseValue;
7295 // struct LDKDecodeError CResult_TxAddInputDecodeErrorZ_get_err(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
7297 export function CResult_TxAddInputDecodeErrorZ_get_err(owner: bigint): bigint {
7298 if(!isWasmInitialized) {
7299 throw new Error("initializeWasm() must be awaited first!");
7301 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_err(owner);
7302 return nativeResponseValue;
7304 // struct LDKTxAddOutput CResult_TxAddOutputDecodeErrorZ_get_ok(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
7306 export function CResult_TxAddOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
7307 if(!isWasmInitialized) {
7308 throw new Error("initializeWasm() must be awaited first!");
7310 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_ok(owner);
7311 return nativeResponseValue;
7313 // struct LDKDecodeError CResult_TxAddOutputDecodeErrorZ_get_err(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
7315 export function CResult_TxAddOutputDecodeErrorZ_get_err(owner: bigint): bigint {
7316 if(!isWasmInitialized) {
7317 throw new Error("initializeWasm() must be awaited first!");
7319 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_err(owner);
7320 return nativeResponseValue;
7322 // struct LDKTxRemoveInput CResult_TxRemoveInputDecodeErrorZ_get_ok(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
7324 export function CResult_TxRemoveInputDecodeErrorZ_get_ok(owner: bigint): bigint {
7325 if(!isWasmInitialized) {
7326 throw new Error("initializeWasm() must be awaited first!");
7328 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_ok(owner);
7329 return nativeResponseValue;
7331 // struct LDKDecodeError CResult_TxRemoveInputDecodeErrorZ_get_err(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
7333 export function CResult_TxRemoveInputDecodeErrorZ_get_err(owner: bigint): bigint {
7334 if(!isWasmInitialized) {
7335 throw new Error("initializeWasm() must be awaited first!");
7337 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_err(owner);
7338 return nativeResponseValue;
7340 // struct LDKTxRemoveOutput CResult_TxRemoveOutputDecodeErrorZ_get_ok(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
7342 export function CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
7343 if(!isWasmInitialized) {
7344 throw new Error("initializeWasm() must be awaited first!");
7346 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner);
7347 return nativeResponseValue;
7349 // struct LDKDecodeError CResult_TxRemoveOutputDecodeErrorZ_get_err(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
7351 export function CResult_TxRemoveOutputDecodeErrorZ_get_err(owner: bigint): bigint {
7352 if(!isWasmInitialized) {
7353 throw new Error("initializeWasm() must be awaited first!");
7355 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_err(owner);
7356 return nativeResponseValue;
7358 // struct LDKTxComplete CResult_TxCompleteDecodeErrorZ_get_ok(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
7360 export function CResult_TxCompleteDecodeErrorZ_get_ok(owner: bigint): bigint {
7361 if(!isWasmInitialized) {
7362 throw new Error("initializeWasm() must be awaited first!");
7364 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_ok(owner);
7365 return nativeResponseValue;
7367 // struct LDKDecodeError CResult_TxCompleteDecodeErrorZ_get_err(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
7369 export function CResult_TxCompleteDecodeErrorZ_get_err(owner: bigint): bigint {
7370 if(!isWasmInitialized) {
7371 throw new Error("initializeWasm() must be awaited first!");
7373 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_err(owner);
7374 return nativeResponseValue;
7376 // struct LDKTxSignatures CResult_TxSignaturesDecodeErrorZ_get_ok(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
7378 export function CResult_TxSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
7379 if(!isWasmInitialized) {
7380 throw new Error("initializeWasm() must be awaited first!");
7382 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_ok(owner);
7383 return nativeResponseValue;
7385 // struct LDKDecodeError CResult_TxSignaturesDecodeErrorZ_get_err(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
7387 export function CResult_TxSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
7388 if(!isWasmInitialized) {
7389 throw new Error("initializeWasm() must be awaited first!");
7391 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_err(owner);
7392 return nativeResponseValue;
7394 // struct LDKTxInitRbf CResult_TxInitRbfDecodeErrorZ_get_ok(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
7396 export function CResult_TxInitRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
7397 if(!isWasmInitialized) {
7398 throw new Error("initializeWasm() must be awaited first!");
7400 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_ok(owner);
7401 return nativeResponseValue;
7403 // struct LDKDecodeError CResult_TxInitRbfDecodeErrorZ_get_err(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
7405 export function CResult_TxInitRbfDecodeErrorZ_get_err(owner: bigint): bigint {
7406 if(!isWasmInitialized) {
7407 throw new Error("initializeWasm() must be awaited first!");
7409 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_err(owner);
7410 return nativeResponseValue;
7412 // struct LDKTxAckRbf CResult_TxAckRbfDecodeErrorZ_get_ok(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
7414 export function CResult_TxAckRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
7415 if(!isWasmInitialized) {
7416 throw new Error("initializeWasm() must be awaited first!");
7418 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_ok(owner);
7419 return nativeResponseValue;
7421 // struct LDKDecodeError CResult_TxAckRbfDecodeErrorZ_get_err(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
7423 export function CResult_TxAckRbfDecodeErrorZ_get_err(owner: bigint): bigint {
7424 if(!isWasmInitialized) {
7425 throw new Error("initializeWasm() must be awaited first!");
7427 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_err(owner);
7428 return nativeResponseValue;
7430 // struct LDKTxAbort CResult_TxAbortDecodeErrorZ_get_ok(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
7432 export function CResult_TxAbortDecodeErrorZ_get_ok(owner: bigint): bigint {
7433 if(!isWasmInitialized) {
7434 throw new Error("initializeWasm() must be awaited first!");
7436 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_ok(owner);
7437 return nativeResponseValue;
7439 // struct LDKDecodeError CResult_TxAbortDecodeErrorZ_get_err(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
7441 export function CResult_TxAbortDecodeErrorZ_get_err(owner: bigint): bigint {
7442 if(!isWasmInitialized) {
7443 throw new Error("initializeWasm() must be awaited first!");
7445 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_err(owner);
7446 return nativeResponseValue;
7448 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
7450 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
7451 if(!isWasmInitialized) {
7452 throw new Error("initializeWasm() must be awaited first!");
7454 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
7455 return nativeResponseValue;
7457 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
7459 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
7460 if(!isWasmInitialized) {
7461 throw new Error("initializeWasm() must be awaited first!");
7463 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
7464 return nativeResponseValue;
7466 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
7468 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
7469 if(!isWasmInitialized) {
7470 throw new Error("initializeWasm() must be awaited first!");
7472 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
7473 return nativeResponseValue;
7475 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
7477 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
7478 if(!isWasmInitialized) {
7479 throw new Error("initializeWasm() must be awaited first!");
7481 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
7482 return nativeResponseValue;
7484 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
7486 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
7487 if(!isWasmInitialized) {
7488 throw new Error("initializeWasm() must be awaited first!");
7490 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
7491 return nativeResponseValue;
7493 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
7495 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
7496 if(!isWasmInitialized) {
7497 throw new Error("initializeWasm() must be awaited first!");
7499 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
7500 return nativeResponseValue;
7502 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
7504 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
7505 if(!isWasmInitialized) {
7506 throw new Error("initializeWasm() must be awaited first!");
7508 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
7509 return nativeResponseValue;
7511 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
7513 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
7514 if(!isWasmInitialized) {
7515 throw new Error("initializeWasm() must be awaited first!");
7517 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
7518 return nativeResponseValue;
7520 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
7522 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
7523 if(!isWasmInitialized) {
7524 throw new Error("initializeWasm() must be awaited first!");
7526 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
7527 return nativeResponseValue;
7529 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
7531 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
7532 if(!isWasmInitialized) {
7533 throw new Error("initializeWasm() must be awaited first!");
7535 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
7536 return nativeResponseValue;
7538 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
7540 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
7541 if(!isWasmInitialized) {
7542 throw new Error("initializeWasm() must be awaited first!");
7544 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
7545 return nativeResponseValue;
7547 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
7549 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
7550 if(!isWasmInitialized) {
7551 throw new Error("initializeWasm() must be awaited first!");
7553 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
7554 return nativeResponseValue;
7556 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
7558 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
7559 if(!isWasmInitialized) {
7560 throw new Error("initializeWasm() must be awaited first!");
7562 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
7563 return nativeResponseValue;
7565 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
7567 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
7568 if(!isWasmInitialized) {
7569 throw new Error("initializeWasm() must be awaited first!");
7571 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
7572 return nativeResponseValue;
7574 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
7576 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
7577 if(!isWasmInitialized) {
7578 throw new Error("initializeWasm() must be awaited first!");
7580 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
7581 return nativeResponseValue;
7583 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
7585 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
7586 if(!isWasmInitialized) {
7587 throw new Error("initializeWasm() must be awaited first!");
7589 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
7590 return nativeResponseValue;
7592 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
7594 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
7595 if(!isWasmInitialized) {
7596 throw new Error("initializeWasm() must be awaited first!");
7598 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
7599 return nativeResponseValue;
7601 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
7603 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
7604 if(!isWasmInitialized) {
7605 throw new Error("initializeWasm() must be awaited first!");
7607 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
7608 return nativeResponseValue;
7610 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
7612 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
7613 if(!isWasmInitialized) {
7614 throw new Error("initializeWasm() must be awaited first!");
7616 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
7617 return nativeResponseValue;
7619 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
7621 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
7626 return nativeResponseValue;
7628 // struct LDKOpenChannelV2 CResult_OpenChannelV2DecodeErrorZ_get_ok(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
7630 export function CResult_OpenChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
7631 if(!isWasmInitialized) {
7632 throw new Error("initializeWasm() must be awaited first!");
7634 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_ok(owner);
7635 return nativeResponseValue;
7637 // struct LDKDecodeError CResult_OpenChannelV2DecodeErrorZ_get_err(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
7639 export function CResult_OpenChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
7640 if(!isWasmInitialized) {
7641 throw new Error("initializeWasm() must be awaited first!");
7643 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_err(owner);
7644 return nativeResponseValue;
7646 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
7648 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
7649 if(!isWasmInitialized) {
7650 throw new Error("initializeWasm() must be awaited first!");
7652 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
7653 return nativeResponseValue;
7655 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
7657 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
7658 if(!isWasmInitialized) {
7659 throw new Error("initializeWasm() must be awaited first!");
7661 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
7662 return nativeResponseValue;
7664 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
7666 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
7667 if(!isWasmInitialized) {
7668 throw new Error("initializeWasm() must be awaited first!");
7670 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
7671 return nativeResponseValue;
7673 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
7675 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
7676 if(!isWasmInitialized) {
7677 throw new Error("initializeWasm() must be awaited first!");
7679 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
7680 return nativeResponseValue;
7682 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
7684 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7685 if(!isWasmInitialized) {
7686 throw new Error("initializeWasm() must be awaited first!");
7688 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
7689 return nativeResponseValue;
7691 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
7693 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7694 if(!isWasmInitialized) {
7695 throw new Error("initializeWasm() must be awaited first!");
7697 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
7698 return nativeResponseValue;
7700 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
7702 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7703 if(!isWasmInitialized) {
7704 throw new Error("initializeWasm() must be awaited first!");
7706 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
7707 return nativeResponseValue;
7709 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
7711 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7712 if(!isWasmInitialized) {
7713 throw new Error("initializeWasm() must be awaited first!");
7715 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
7716 return nativeResponseValue;
7718 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
7720 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
7721 if(!isWasmInitialized) {
7722 throw new Error("initializeWasm() must be awaited first!");
7724 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
7725 return nativeResponseValue;
7727 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
7729 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
7730 if(!isWasmInitialized) {
7731 throw new Error("initializeWasm() must be awaited first!");
7733 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
7734 return nativeResponseValue;
7736 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
7738 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7739 if(!isWasmInitialized) {
7740 throw new Error("initializeWasm() must be awaited first!");
7742 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
7743 return nativeResponseValue;
7745 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
7747 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7748 if(!isWasmInitialized) {
7749 throw new Error("initializeWasm() must be awaited first!");
7751 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
7752 return nativeResponseValue;
7754 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
7756 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7757 if(!isWasmInitialized) {
7758 throw new Error("initializeWasm() must be awaited first!");
7760 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
7761 return nativeResponseValue;
7763 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
7765 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7766 if(!isWasmInitialized) {
7767 throw new Error("initializeWasm() must be awaited first!");
7769 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
7770 return nativeResponseValue;
7772 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
7774 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7775 if(!isWasmInitialized) {
7776 throw new Error("initializeWasm() must be awaited first!");
7778 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
7779 return nativeResponseValue;
7781 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
7783 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7784 if(!isWasmInitialized) {
7785 throw new Error("initializeWasm() must be awaited first!");
7787 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
7788 return nativeResponseValue;
7790 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
7792 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
7793 if(!isWasmInitialized) {
7794 throw new Error("initializeWasm() must be awaited first!");
7796 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
7797 return nativeResponseValue;
7799 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
7801 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
7802 if(!isWasmInitialized) {
7803 throw new Error("initializeWasm() must be awaited first!");
7805 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
7806 return nativeResponseValue;
7808 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
7810 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
7811 if(!isWasmInitialized) {
7812 throw new Error("initializeWasm() must be awaited first!");
7814 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
7815 return nativeResponseValue;
7817 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
7819 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
7820 if(!isWasmInitialized) {
7821 throw new Error("initializeWasm() must be awaited first!");
7823 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
7824 return nativeResponseValue;
7826 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7828 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7829 if(!isWasmInitialized) {
7830 throw new Error("initializeWasm() must be awaited first!");
7832 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
7833 return nativeResponseValue;
7835 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7837 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7838 if(!isWasmInitialized) {
7839 throw new Error("initializeWasm() must be awaited first!");
7841 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
7842 return nativeResponseValue;
7844 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7846 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7847 if(!isWasmInitialized) {
7848 throw new Error("initializeWasm() must be awaited first!");
7850 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
7851 return nativeResponseValue;
7853 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7855 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7856 if(!isWasmInitialized) {
7857 throw new Error("initializeWasm() must be awaited first!");
7859 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
7860 return nativeResponseValue;
7862 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7864 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
7865 if(!isWasmInitialized) {
7866 throw new Error("initializeWasm() must be awaited first!");
7868 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
7869 return nativeResponseValue;
7871 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7873 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
7874 if(!isWasmInitialized) {
7875 throw new Error("initializeWasm() must be awaited first!");
7877 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
7878 return nativeResponseValue;
7880 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7882 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
7883 if(!isWasmInitialized) {
7884 throw new Error("initializeWasm() must be awaited first!");
7886 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
7887 return nativeResponseValue;
7889 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7891 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
7892 if(!isWasmInitialized) {
7893 throw new Error("initializeWasm() must be awaited first!");
7895 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
7896 return nativeResponseValue;
7898 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
7900 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
7905 return nativeResponseValue;
7907 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
7909 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
7914 return nativeResponseValue;
7916 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
7918 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7919 if(!isWasmInitialized) {
7920 throw new Error("initializeWasm() must be awaited first!");
7922 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
7923 return nativeResponseValue;
7925 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
7927 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7928 if(!isWasmInitialized) {
7929 throw new Error("initializeWasm() must be awaited first!");
7931 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
7932 return nativeResponseValue;
7934 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7936 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7937 if(!isWasmInitialized) {
7938 throw new Error("initializeWasm() must be awaited first!");
7940 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
7941 return nativeResponseValue;
7943 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7945 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7946 if(!isWasmInitialized) {
7947 throw new Error("initializeWasm() must be awaited first!");
7949 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
7950 return nativeResponseValue;
7952 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7954 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7955 if(!isWasmInitialized) {
7956 throw new Error("initializeWasm() must be awaited first!");
7958 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
7959 return nativeResponseValue;
7961 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7963 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7964 if(!isWasmInitialized) {
7965 throw new Error("initializeWasm() must be awaited first!");
7967 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
7968 return nativeResponseValue;
7970 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
7972 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
7973 if(!isWasmInitialized) {
7974 throw new Error("initializeWasm() must be awaited first!");
7976 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
7977 return nativeResponseValue;
7979 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
7981 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
7982 if(!isWasmInitialized) {
7983 throw new Error("initializeWasm() must be awaited first!");
7985 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
7986 return nativeResponseValue;
7988 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
7990 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
7991 if(!isWasmInitialized) {
7992 throw new Error("initializeWasm() must be awaited first!");
7994 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
7995 return nativeResponseValue;
7997 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
7999 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
8000 if(!isWasmInitialized) {
8001 throw new Error("initializeWasm() must be awaited first!");
8003 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
8004 return nativeResponseValue;
8006 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
8008 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
8009 if(!isWasmInitialized) {
8010 throw new Error("initializeWasm() must be awaited first!");
8012 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
8013 return nativeResponseValue;
8015 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
8017 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
8018 if(!isWasmInitialized) {
8019 throw new Error("initializeWasm() must be awaited first!");
8021 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
8022 return nativeResponseValue;
8024 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
8026 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
8027 if(!isWasmInitialized) {
8028 throw new Error("initializeWasm() must be awaited first!");
8030 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
8031 return nativeResponseValue;
8033 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
8035 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
8036 if(!isWasmInitialized) {
8037 throw new Error("initializeWasm() must be awaited first!");
8039 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
8040 return nativeResponseValue;
8042 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
8044 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
8045 if(!isWasmInitialized) {
8046 throw new Error("initializeWasm() must be awaited first!");
8048 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
8049 return nativeResponseValue;
8051 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
8053 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
8054 if(!isWasmInitialized) {
8055 throw new Error("initializeWasm() must be awaited first!");
8057 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
8058 return nativeResponseValue;
8061 export class LDKCOption_KeyPairZ {
8062 protected constructor() {}
8065 export function LDKCOption_KeyPairZ_ty_from_ptr(ptr: bigint): number {
8066 if(!isWasmInitialized) {
8067 throw new Error("initializeWasm() must be awaited first!");
8069 const nativeResponseValue = wasm.TS_LDKCOption_KeyPairZ_ty_from_ptr(ptr);
8070 return nativeResponseValue;
8073 export function LDKCOption_KeyPairZ_Some_get_some(ptr: bigint): number {
8074 if(!isWasmInitialized) {
8075 throw new Error("initializeWasm() must be awaited first!");
8077 const nativeResponseValue = wasm.TS_LDKCOption_KeyPairZ_Some_get_some(ptr);
8078 return nativeResponseValue;
8080 // struct LDKCOption_KeyPairZ CResult_COption_KeyPairZNoneZ_get_ok(LDKCResult_COption_KeyPairZNoneZ *NONNULL_PTR owner);
8082 export function CResult_COption_KeyPairZNoneZ_get_ok(owner: bigint): bigint {
8083 if(!isWasmInitialized) {
8084 throw new Error("initializeWasm() must be awaited first!");
8086 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_get_ok(owner);
8087 return nativeResponseValue;
8089 // void CResult_COption_KeyPairZNoneZ_get_err(LDKCResult_COption_KeyPairZNoneZ *NONNULL_PTR owner);
8091 export function CResult_COption_KeyPairZNoneZ_get_err(owner: bigint): void {
8092 if(!isWasmInitialized) {
8093 throw new Error("initializeWasm() must be awaited first!");
8095 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_get_err(owner);
8096 // debug statements here
8098 // struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
8100 export function CResult_InvoiceErrorDecodeErrorZ_get_ok(owner: bigint): bigint {
8101 if(!isWasmInitialized) {
8102 throw new Error("initializeWasm() must be awaited first!");
8104 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_ok(owner);
8105 return nativeResponseValue;
8107 // struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
8109 export function CResult_InvoiceErrorDecodeErrorZ_get_err(owner: bigint): bigint {
8110 if(!isWasmInitialized) {
8111 throw new Error("initializeWasm() must be awaited first!");
8113 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_err(owner);
8114 return nativeResponseValue;
8117 export interface LDKFilter {
8118 register_tx (txid: number, script_pubkey: number): void;
8119 register_output (output: bigint): void;
8123 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
8124 if(!isWasmInitialized) {
8125 throw new Error("initializeWasm() must be awaited first!");
8127 var new_obj_idx = js_objs.length;
8128 for (var i = 0; i < js_objs.length; i++) {
8129 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8131 js_objs[i] = new WeakRef(impl);
8132 return [wasm.TS_LDKFilter_new(i), i];
8134 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
8136 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
8137 if(!isWasmInitialized) {
8138 throw new Error("initializeWasm() must be awaited first!");
8140 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
8141 // debug statements here
8143 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
8145 export function Filter_register_output(this_arg: bigint, output: bigint): void {
8146 if(!isWasmInitialized) {
8147 throw new Error("initializeWasm() must be awaited first!");
8149 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
8150 // debug statements here
8153 export class LDKCOption_FilterZ {
8154 protected constructor() {}
8157 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
8158 if(!isWasmInitialized) {
8159 throw new Error("initializeWasm() must be awaited first!");
8161 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
8162 return nativeResponseValue;
8165 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
8166 if(!isWasmInitialized) {
8167 throw new Error("initializeWasm() must be awaited first!");
8169 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
8170 return nativeResponseValue;
8172 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
8174 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
8175 if(!isWasmInitialized) {
8176 throw new Error("initializeWasm() must be awaited first!");
8178 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
8179 return nativeResponseValue;
8181 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
8183 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
8184 if(!isWasmInitialized) {
8185 throw new Error("initializeWasm() must be awaited first!");
8187 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
8188 // debug statements here
8190 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
8192 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
8193 if(!isWasmInitialized) {
8194 throw new Error("initializeWasm() must be awaited first!");
8196 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
8197 return nativeResponseValue;
8199 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
8201 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
8202 if(!isWasmInitialized) {
8203 throw new Error("initializeWasm() must be awaited first!");
8205 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
8206 return nativeResponseValue;
8209 export class LDKSignOrCreationError {
8210 protected constructor() {}
8213 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
8214 if(!isWasmInitialized) {
8215 throw new Error("initializeWasm() must be awaited first!");
8217 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
8218 return nativeResponseValue;
8221 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
8222 if(!isWasmInitialized) {
8223 throw new Error("initializeWasm() must be awaited first!");
8225 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
8226 return nativeResponseValue;
8228 // struct LDKBolt11Invoice CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
8230 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
8231 if(!isWasmInitialized) {
8232 throw new Error("initializeWasm() must be awaited first!");
8234 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner);
8235 return nativeResponseValue;
8237 // struct LDKSignOrCreationError CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
8239 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
8240 if(!isWasmInitialized) {
8241 throw new Error("initializeWasm() must be awaited first!");
8243 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner);
8244 return nativeResponseValue;
8247 export class LDKBolt11ParseError {
8248 protected constructor() {}
8251 export function LDKBolt11ParseError_ty_from_ptr(ptr: bigint): number {
8252 if(!isWasmInitialized) {
8253 throw new Error("initializeWasm() must be awaited first!");
8255 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ty_from_ptr(ptr);
8256 return nativeResponseValue;
8259 export function LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
8260 if(!isWasmInitialized) {
8261 throw new Error("initializeWasm() must be awaited first!");
8263 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr);
8264 return nativeResponseValue;
8267 export function LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
8268 if(!isWasmInitialized) {
8269 throw new Error("initializeWasm() must be awaited first!");
8271 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr);
8272 return nativeResponseValue;
8275 export function LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
8276 if(!isWasmInitialized) {
8277 throw new Error("initializeWasm() must be awaited first!");
8279 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr);
8280 return nativeResponseValue;
8283 export function LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
8284 if(!isWasmInitialized) {
8285 throw new Error("initializeWasm() must be awaited first!");
8287 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr);
8288 return nativeResponseValue;
8291 export function LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
8292 if(!isWasmInitialized) {
8293 throw new Error("initializeWasm() must be awaited first!");
8295 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
8296 return nativeResponseValue;
8298 // enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8300 export function CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner: bigint): SiPrefix {
8301 if(!isWasmInitialized) {
8302 throw new Error("initializeWasm() must be awaited first!");
8304 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner);
8305 return nativeResponseValue;
8307 // struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8309 export function CResult_SiPrefixBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8310 if(!isWasmInitialized) {
8311 throw new Error("initializeWasm() must be awaited first!");
8313 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_err(owner);
8314 return nativeResponseValue;
8317 export class LDKParseOrSemanticError {
8318 protected constructor() {}
8321 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
8322 if(!isWasmInitialized) {
8323 throw new Error("initializeWasm() must be awaited first!");
8325 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
8326 return nativeResponseValue;
8329 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
8330 if(!isWasmInitialized) {
8331 throw new Error("initializeWasm() must be awaited first!");
8333 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
8334 return nativeResponseValue;
8337 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): Bolt11SemanticError {
8338 if(!isWasmInitialized) {
8339 throw new Error("initializeWasm() must be awaited first!");
8341 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
8342 return nativeResponseValue;
8344 // struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8346 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
8347 if(!isWasmInitialized) {
8348 throw new Error("initializeWasm() must be awaited first!");
8350 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner);
8351 return nativeResponseValue;
8353 // struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8355 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
8356 if(!isWasmInitialized) {
8357 throw new Error("initializeWasm() must be awaited first!");
8359 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner);
8360 return nativeResponseValue;
8362 // struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8364 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner: bigint): bigint {
8365 if(!isWasmInitialized) {
8366 throw new Error("initializeWasm() must be awaited first!");
8368 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner);
8369 return nativeResponseValue;
8371 // struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8373 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8374 if(!isWasmInitialized) {
8375 throw new Error("initializeWasm() must be awaited first!");
8377 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner);
8378 return nativeResponseValue;
8380 // struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8382 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner: bigint): bigint {
8383 if(!isWasmInitialized) {
8384 throw new Error("initializeWasm() must be awaited first!");
8386 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner);
8387 return nativeResponseValue;
8389 // struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8391 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner: bigint): number {
8392 if(!isWasmInitialized) {
8393 throw new Error("initializeWasm() must be awaited first!");
8395 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner);
8396 return nativeResponseValue;
8398 // struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8400 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner: bigint): bigint {
8401 if(!isWasmInitialized) {
8402 throw new Error("initializeWasm() must be awaited first!");
8404 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner);
8405 return nativeResponseValue;
8407 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
8409 export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
8410 if(!isWasmInitialized) {
8411 throw new Error("initializeWasm() must be awaited first!");
8413 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
8414 return nativeResponseValue;
8416 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
8418 export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
8419 if(!isWasmInitialized) {
8420 throw new Error("initializeWasm() must be awaited first!");
8422 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
8423 return nativeResponseValue;
8425 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8427 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
8428 if(!isWasmInitialized) {
8429 throw new Error("initializeWasm() must be awaited first!");
8431 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
8432 return nativeResponseValue;
8434 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8436 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
8437 if(!isWasmInitialized) {
8438 throw new Error("initializeWasm() must be awaited first!");
8440 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
8441 return nativeResponseValue;
8443 // void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8445 export function CResult_NoneBolt11SemanticErrorZ_get_ok(owner: bigint): void {
8446 if(!isWasmInitialized) {
8447 throw new Error("initializeWasm() must be awaited first!");
8449 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_ok(owner);
8450 // debug statements here
8452 // enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8454 export function CResult_NoneBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8455 if(!isWasmInitialized) {
8456 throw new Error("initializeWasm() must be awaited first!");
8458 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_err(owner);
8459 return nativeResponseValue;
8461 // struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
8463 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner: bigint): bigint {
8464 if(!isWasmInitialized) {
8465 throw new Error("initializeWasm() must be awaited first!");
8467 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner);
8468 return nativeResponseValue;
8470 // enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
8472 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8473 if(!isWasmInitialized) {
8474 throw new Error("initializeWasm() must be awaited first!");
8476 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner);
8477 return nativeResponseValue;
8479 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
8481 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
8482 if(!isWasmInitialized) {
8483 throw new Error("initializeWasm() must be awaited first!");
8485 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
8486 return nativeResponseValue;
8488 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
8490 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
8491 if(!isWasmInitialized) {
8492 throw new Error("initializeWasm() must be awaited first!");
8494 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
8495 return nativeResponseValue;
8497 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
8499 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
8500 if(!isWasmInitialized) {
8501 throw new Error("initializeWasm() must be awaited first!");
8503 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
8504 return nativeResponseValue;
8506 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
8508 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
8509 if(!isWasmInitialized) {
8510 throw new Error("initializeWasm() must be awaited first!");
8512 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
8513 return nativeResponseValue;
8516 export interface LDKScore {
8517 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint, score_params: bigint): bigint;
8518 payment_path_failed (path: bigint, short_channel_id: bigint): void;
8519 payment_path_successful (path: bigint): void;
8520 probe_failed (path: bigint, short_channel_id: bigint): void;
8521 probe_successful (path: bigint): void;
8526 export function LDKScore_new(impl: LDKScore): [bigint, number] {
8527 if(!isWasmInitialized) {
8528 throw new Error("initializeWasm() must be awaited first!");
8530 var new_obj_idx = js_objs.length;
8531 for (var i = 0; i < js_objs.length; i++) {
8532 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8534 js_objs[i] = new WeakRef(impl);
8535 return [wasm.TS_LDKScore_new(i), i];
8537 // 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, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params
8539 export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint, score_params: bigint): bigint {
8540 if(!isWasmInitialized) {
8541 throw new Error("initializeWasm() must be awaited first!");
8543 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage, score_params);
8544 return nativeResponseValue;
8546 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
8548 export function Score_payment_path_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
8549 if(!isWasmInitialized) {
8550 throw new Error("initializeWasm() must be awaited first!");
8552 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
8553 // debug statements here
8555 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
8557 export function Score_payment_path_successful(this_arg: bigint, path: bigint): void {
8558 if(!isWasmInitialized) {
8559 throw new Error("initializeWasm() must be awaited first!");
8561 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
8562 // debug statements here
8564 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
8566 export function Score_probe_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
8567 if(!isWasmInitialized) {
8568 throw new Error("initializeWasm() must be awaited first!");
8570 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
8571 // debug statements here
8573 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
8575 export function Score_probe_successful(this_arg: bigint, path: bigint): void {
8576 if(!isWasmInitialized) {
8577 throw new Error("initializeWasm() must be awaited first!");
8579 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
8580 // debug statements here
8582 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
8584 export function Score_write(this_arg: bigint): number {
8585 if(!isWasmInitialized) {
8586 throw new Error("initializeWasm() must be awaited first!");
8588 const nativeResponseValue = wasm.TS_Score_write(this_arg);
8589 return nativeResponseValue;
8592 export interface LDKLockableScore {
8597 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
8598 if(!isWasmInitialized) {
8599 throw new Error("initializeWasm() must be awaited first!");
8601 var new_obj_idx = js_objs.length;
8602 for (var i = 0; i < js_objs.length; i++) {
8603 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8605 js_objs[i] = new WeakRef(impl);
8606 return [wasm.TS_LDKLockableScore_new(i), i];
8608 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
8610 export function LockableScore_lock(this_arg: bigint): bigint {
8611 if(!isWasmInitialized) {
8612 throw new Error("initializeWasm() must be awaited first!");
8614 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
8615 return nativeResponseValue;
8618 export interface LDKWriteableScore {
8623 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
8624 if(!isWasmInitialized) {
8625 throw new Error("initializeWasm() must be awaited first!");
8627 var new_obj_idx = js_objs.length;
8628 for (var i = 0; i < js_objs.length; i++) {
8629 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8631 js_objs[i] = new WeakRef(impl);
8632 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
8634 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
8636 export function WriteableScore_write(this_arg: bigint): number {
8637 if(!isWasmInitialized) {
8638 throw new Error("initializeWasm() must be awaited first!");
8640 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
8641 return nativeResponseValue;
8644 export interface LDKPersister {
8645 persist_manager (channel_manager: bigint): bigint;
8646 persist_graph (network_graph: bigint): bigint;
8647 persist_scorer (scorer: bigint): bigint;
8651 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
8652 if(!isWasmInitialized) {
8653 throw new Error("initializeWasm() must be awaited first!");
8655 var new_obj_idx = js_objs.length;
8656 for (var i = 0; i < js_objs.length; i++) {
8657 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8659 js_objs[i] = new WeakRef(impl);
8660 return [wasm.TS_LDKPersister_new(i), i];
8662 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
8664 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
8665 if(!isWasmInitialized) {
8666 throw new Error("initializeWasm() must be awaited first!");
8668 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
8669 return nativeResponseValue;
8671 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
8673 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
8674 if(!isWasmInitialized) {
8675 throw new Error("initializeWasm() must be awaited first!");
8677 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
8678 return nativeResponseValue;
8680 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
8682 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
8683 if(!isWasmInitialized) {
8684 throw new Error("initializeWasm() must be awaited first!");
8686 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
8687 return nativeResponseValue;
8690 export interface LDKFutureCallback {
8695 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
8696 if(!isWasmInitialized) {
8697 throw new Error("initializeWasm() must be awaited first!");
8699 var new_obj_idx = js_objs.length;
8700 for (var i = 0; i < js_objs.length; i++) {
8701 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8703 js_objs[i] = new WeakRef(impl);
8704 return [wasm.TS_LDKFutureCallback_new(i), i];
8706 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
8708 export function FutureCallback_call(this_arg: bigint): void {
8709 if(!isWasmInitialized) {
8710 throw new Error("initializeWasm() must be awaited first!");
8712 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
8713 // debug statements here
8716 export interface LDKListen {
8717 filtered_block_connected (header: number, txdata: number, height: number): void;
8718 block_connected (block: number, height: number): void;
8719 block_disconnected (header: number, height: number): void;
8723 export function LDKListen_new(impl: LDKListen): [bigint, number] {
8724 if(!isWasmInitialized) {
8725 throw new Error("initializeWasm() must be awaited first!");
8727 var new_obj_idx = js_objs.length;
8728 for (var i = 0; i < js_objs.length; i++) {
8729 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8731 js_objs[i] = new WeakRef(impl);
8732 return [wasm.TS_LDKListen_new(i), i];
8734 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
8736 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
8737 if(!isWasmInitialized) {
8738 throw new Error("initializeWasm() must be awaited first!");
8740 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
8741 // debug statements here
8743 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
8745 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
8746 if(!isWasmInitialized) {
8747 throw new Error("initializeWasm() must be awaited first!");
8749 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
8750 // debug statements here
8752 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
8754 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
8755 if(!isWasmInitialized) {
8756 throw new Error("initializeWasm() must be awaited first!");
8758 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
8759 // debug statements here
8762 export interface LDKConfirm {
8763 transactions_confirmed (header: number, txdata: number, height: number): void;
8764 transaction_unconfirmed (txid: number): void;
8765 best_block_updated (header: number, height: number): void;
8766 get_relevant_txids (): number;
8770 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
8771 if(!isWasmInitialized) {
8772 throw new Error("initializeWasm() must be awaited first!");
8774 var new_obj_idx = js_objs.length;
8775 for (var i = 0; i < js_objs.length; i++) {
8776 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8778 js_objs[i] = new WeakRef(impl);
8779 return [wasm.TS_LDKConfirm_new(i), i];
8781 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
8783 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
8784 if(!isWasmInitialized) {
8785 throw new Error("initializeWasm() must be awaited first!");
8787 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
8788 // debug statements here
8790 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
8792 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
8793 if(!isWasmInitialized) {
8794 throw new Error("initializeWasm() must be awaited first!");
8796 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
8797 // debug statements here
8799 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
8801 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
8802 if(!isWasmInitialized) {
8803 throw new Error("initializeWasm() must be awaited first!");
8805 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
8806 // debug statements here
8808 // LDKCVec_C2Tuple_TxidCOption_BlockHashZZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
8810 export function Confirm_get_relevant_txids(this_arg: bigint): number {
8811 if(!isWasmInitialized) {
8812 throw new Error("initializeWasm() must be awaited first!");
8814 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
8815 return nativeResponseValue;
8818 export interface LDKPersist {
8819 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
8820 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
8824 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
8825 if(!isWasmInitialized) {
8826 throw new Error("initializeWasm() must be awaited first!");
8828 var new_obj_idx = js_objs.length;
8829 for (var i = 0; i < js_objs.length; i++) {
8830 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8832 js_objs[i] = new WeakRef(impl);
8833 return [wasm.TS_LDKPersist_new(i), i];
8835 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
8837 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
8838 if(!isWasmInitialized) {
8839 throw new Error("initializeWasm() must be awaited first!");
8841 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
8842 return nativeResponseValue;
8844 // 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
8846 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
8847 if(!isWasmInitialized) {
8848 throw new Error("initializeWasm() must be awaited first!");
8850 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
8851 return nativeResponseValue;
8854 export interface LDKEventHandler {
8855 handle_event (event: bigint): void;
8859 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
8860 if(!isWasmInitialized) {
8861 throw new Error("initializeWasm() must be awaited first!");
8863 var new_obj_idx = js_objs.length;
8864 for (var i = 0; i < js_objs.length; i++) {
8865 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8867 js_objs[i] = new WeakRef(impl);
8868 return [wasm.TS_LDKEventHandler_new(i), i];
8870 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
8872 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
8873 if(!isWasmInitialized) {
8874 throw new Error("initializeWasm() must be awaited first!");
8876 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
8877 // debug statements here
8880 export interface LDKEventsProvider {
8881 process_pending_events (handler: bigint): void;
8885 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
8886 if(!isWasmInitialized) {
8887 throw new Error("initializeWasm() must be awaited first!");
8889 var new_obj_idx = js_objs.length;
8890 for (var i = 0; i < js_objs.length; i++) {
8891 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8893 js_objs[i] = new WeakRef(impl);
8894 return [wasm.TS_LDKEventsProvider_new(i), i];
8896 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
8898 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
8899 if(!isWasmInitialized) {
8900 throw new Error("initializeWasm() must be awaited first!");
8902 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
8903 // debug statements here
8906 export class LDKRetry {
8907 protected constructor() {}
8910 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
8911 if(!isWasmInitialized) {
8912 throw new Error("initializeWasm() must be awaited first!");
8914 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
8915 return nativeResponseValue;
8918 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
8919 if(!isWasmInitialized) {
8920 throw new Error("initializeWasm() must be awaited first!");
8922 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
8923 return nativeResponseValue;
8926 export interface LDKMessageSendEventsProvider {
8927 get_and_clear_pending_msg_events (): number;
8931 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
8932 if(!isWasmInitialized) {
8933 throw new Error("initializeWasm() must be awaited first!");
8935 var new_obj_idx = js_objs.length;
8936 for (var i = 0; i < js_objs.length; i++) {
8937 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8939 js_objs[i] = new WeakRef(impl);
8940 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
8942 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
8944 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
8945 if(!isWasmInitialized) {
8946 throw new Error("initializeWasm() must be awaited first!");
8948 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
8949 return nativeResponseValue;
8952 export interface LDKChannelMessageHandler {
8953 handle_open_channel (their_node_id: number, msg: bigint): void;
8954 handle_open_channel_v2 (their_node_id: number, msg: bigint): void;
8955 handle_accept_channel (their_node_id: number, msg: bigint): void;
8956 handle_accept_channel_v2 (their_node_id: number, msg: bigint): void;
8957 handle_funding_created (their_node_id: number, msg: bigint): void;
8958 handle_funding_signed (their_node_id: number, msg: bigint): void;
8959 handle_channel_ready (their_node_id: number, msg: bigint): void;
8960 handle_shutdown (their_node_id: number, msg: bigint): void;
8961 handle_closing_signed (their_node_id: number, msg: bigint): void;
8962 handle_tx_add_input (their_node_id: number, msg: bigint): void;
8963 handle_tx_add_output (their_node_id: number, msg: bigint): void;
8964 handle_tx_remove_input (their_node_id: number, msg: bigint): void;
8965 handle_tx_remove_output (their_node_id: number, msg: bigint): void;
8966 handle_tx_complete (their_node_id: number, msg: bigint): void;
8967 handle_tx_signatures (their_node_id: number, msg: bigint): void;
8968 handle_tx_init_rbf (their_node_id: number, msg: bigint): void;
8969 handle_tx_ack_rbf (their_node_id: number, msg: bigint): void;
8970 handle_tx_abort (their_node_id: number, msg: bigint): void;
8971 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
8972 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
8973 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
8974 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
8975 handle_commitment_signed (their_node_id: number, msg: bigint): void;
8976 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
8977 handle_update_fee (their_node_id: number, msg: bigint): void;
8978 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
8979 peer_disconnected (their_node_id: number): void;
8980 peer_connected (their_node_id: number, msg: bigint, inbound: boolean): bigint;
8981 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
8982 handle_channel_update (their_node_id: number, msg: bigint): void;
8983 handle_error (their_node_id: number, msg: bigint): void;
8984 provided_node_features (): bigint;
8985 provided_init_features (their_node_id: number): bigint;
8986 get_genesis_hashes (): bigint;
8990 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
8991 if(!isWasmInitialized) {
8992 throw new Error("initializeWasm() must be awaited first!");
8994 var new_obj_idx = js_objs.length;
8995 for (var i = 0; i < js_objs.length; i++) {
8996 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8998 js_objs[i] = new WeakRef(impl);
8999 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
9001 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
9003 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
9004 if(!isWasmInitialized) {
9005 throw new Error("initializeWasm() must be awaited first!");
9007 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, msg);
9008 // debug statements here
9010 // void ChannelMessageHandler_handle_open_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg
9012 export function ChannelMessageHandler_handle_open_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
9013 if(!isWasmInitialized) {
9014 throw new Error("initializeWasm() must be awaited first!");
9016 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel_v2(this_arg, their_node_id, msg);
9017 // debug statements here
9019 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
9021 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
9022 if(!isWasmInitialized) {
9023 throw new Error("initializeWasm() must be awaited first!");
9025 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, msg);
9026 // debug statements here
9028 // void ChannelMessageHandler_handle_accept_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg
9030 export function ChannelMessageHandler_handle_accept_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
9031 if(!isWasmInitialized) {
9032 throw new Error("initializeWasm() must be awaited first!");
9034 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel_v2(this_arg, their_node_id, msg);
9035 // debug statements here
9037 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
9039 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
9040 if(!isWasmInitialized) {
9041 throw new Error("initializeWasm() must be awaited first!");
9043 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
9044 // debug statements here
9046 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
9048 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9049 if(!isWasmInitialized) {
9050 throw new Error("initializeWasm() must be awaited first!");
9052 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
9053 // debug statements here
9055 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
9057 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
9058 if(!isWasmInitialized) {
9059 throw new Error("initializeWasm() must be awaited first!");
9061 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
9062 // debug statements here
9064 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
9066 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, msg: bigint): void {
9067 if(!isWasmInitialized) {
9068 throw new Error("initializeWasm() must be awaited first!");
9070 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, msg);
9071 // debug statements here
9073 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
9075 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9076 if(!isWasmInitialized) {
9077 throw new Error("initializeWasm() must be awaited first!");
9079 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
9080 // debug statements here
9082 // void ChannelMessageHandler_handle_tx_add_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg
9084 export function ChannelMessageHandler_handle_tx_add_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
9085 if(!isWasmInitialized) {
9086 throw new Error("initializeWasm() must be awaited first!");
9088 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_input(this_arg, their_node_id, msg);
9089 // debug statements here
9091 // void ChannelMessageHandler_handle_tx_add_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg
9093 export function ChannelMessageHandler_handle_tx_add_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
9094 if(!isWasmInitialized) {
9095 throw new Error("initializeWasm() must be awaited first!");
9097 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_output(this_arg, their_node_id, msg);
9098 // debug statements here
9100 // void ChannelMessageHandler_handle_tx_remove_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg
9102 export function ChannelMessageHandler_handle_tx_remove_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
9103 if(!isWasmInitialized) {
9104 throw new Error("initializeWasm() must be awaited first!");
9106 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_input(this_arg, their_node_id, msg);
9107 // debug statements here
9109 // void ChannelMessageHandler_handle_tx_remove_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg
9111 export function ChannelMessageHandler_handle_tx_remove_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
9112 if(!isWasmInitialized) {
9113 throw new Error("initializeWasm() must be awaited first!");
9115 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_output(this_arg, their_node_id, msg);
9116 // debug statements here
9118 // void ChannelMessageHandler_handle_tx_complete LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg
9120 export function ChannelMessageHandler_handle_tx_complete(this_arg: bigint, their_node_id: number, msg: bigint): void {
9121 if(!isWasmInitialized) {
9122 throw new Error("initializeWasm() must be awaited first!");
9124 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_complete(this_arg, their_node_id, msg);
9125 // debug statements here
9127 // void ChannelMessageHandler_handle_tx_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg
9129 export function ChannelMessageHandler_handle_tx_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
9130 if(!isWasmInitialized) {
9131 throw new Error("initializeWasm() must be awaited first!");
9133 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_signatures(this_arg, their_node_id, msg);
9134 // debug statements here
9136 // void ChannelMessageHandler_handle_tx_init_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg
9138 export function ChannelMessageHandler_handle_tx_init_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
9139 if(!isWasmInitialized) {
9140 throw new Error("initializeWasm() must be awaited first!");
9142 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_init_rbf(this_arg, their_node_id, msg);
9143 // debug statements here
9145 // void ChannelMessageHandler_handle_tx_ack_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg
9147 export function ChannelMessageHandler_handle_tx_ack_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
9148 if(!isWasmInitialized) {
9149 throw new Error("initializeWasm() must be awaited first!");
9151 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_ack_rbf(this_arg, their_node_id, msg);
9152 // debug statements here
9154 // void ChannelMessageHandler_handle_tx_abort LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg
9156 export function ChannelMessageHandler_handle_tx_abort(this_arg: bigint, their_node_id: number, msg: bigint): void {
9157 if(!isWasmInitialized) {
9158 throw new Error("initializeWasm() must be awaited first!");
9160 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_abort(this_arg, their_node_id, msg);
9161 // debug statements here
9163 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
9165 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9166 if(!isWasmInitialized) {
9167 throw new Error("initializeWasm() must be awaited first!");
9169 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
9170 // debug statements here
9172 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
9174 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9175 if(!isWasmInitialized) {
9176 throw new Error("initializeWasm() must be awaited first!");
9178 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
9179 // debug statements here
9181 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
9183 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9184 if(!isWasmInitialized) {
9185 throw new Error("initializeWasm() must be awaited first!");
9187 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
9188 // debug statements here
9190 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
9192 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9193 if(!isWasmInitialized) {
9194 throw new Error("initializeWasm() must be awaited first!");
9196 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
9197 // debug statements here
9199 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
9201 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9202 if(!isWasmInitialized) {
9203 throw new Error("initializeWasm() must be awaited first!");
9205 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
9206 // debug statements here
9208 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
9210 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
9211 if(!isWasmInitialized) {
9212 throw new Error("initializeWasm() must be awaited first!");
9214 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
9215 // debug statements here
9217 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
9219 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
9220 if(!isWasmInitialized) {
9221 throw new Error("initializeWasm() must be awaited first!");
9223 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
9224 // debug statements here
9226 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
9228 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
9229 if(!isWasmInitialized) {
9230 throw new Error("initializeWasm() must be awaited first!");
9232 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
9233 // debug statements here
9235 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9237 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
9238 if(!isWasmInitialized) {
9239 throw new Error("initializeWasm() must be awaited first!");
9241 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id);
9242 // debug statements here
9244 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
9246 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint, inbound: boolean): bigint {
9247 if(!isWasmInitialized) {
9248 throw new Error("initializeWasm() must be awaited first!");
9250 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg, inbound);
9251 return nativeResponseValue;
9253 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
9255 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
9256 if(!isWasmInitialized) {
9257 throw new Error("initializeWasm() must be awaited first!");
9259 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
9260 // debug statements here
9262 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
9264 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
9265 if(!isWasmInitialized) {
9266 throw new Error("initializeWasm() must be awaited first!");
9268 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
9269 // debug statements here
9271 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
9273 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
9274 if(!isWasmInitialized) {
9275 throw new Error("initializeWasm() must be awaited first!");
9277 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
9278 // debug statements here
9280 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
9282 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
9283 if(!isWasmInitialized) {
9284 throw new Error("initializeWasm() must be awaited first!");
9286 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
9287 return nativeResponseValue;
9289 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9291 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
9292 if(!isWasmInitialized) {
9293 throw new Error("initializeWasm() must be awaited first!");
9295 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
9296 return nativeResponseValue;
9298 // LDKCOption_CVec_ChainHashZZ ChannelMessageHandler_get_genesis_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
9300 export function ChannelMessageHandler_get_genesis_hashes(this_arg: bigint): bigint {
9301 if(!isWasmInitialized) {
9302 throw new Error("initializeWasm() must be awaited first!");
9304 const nativeResponseValue = wasm.TS_ChannelMessageHandler_get_genesis_hashes(this_arg);
9305 return nativeResponseValue;
9308 export interface LDKRoutingMessageHandler {
9309 handle_node_announcement (msg: bigint): bigint;
9310 handle_channel_announcement (msg: bigint): bigint;
9311 handle_channel_update (msg: bigint): bigint;
9312 get_next_channel_announcement (starting_point: bigint): bigint;
9313 get_next_node_announcement (starting_point: bigint): bigint;
9314 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
9315 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
9316 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
9317 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
9318 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
9319 processing_queue_high (): boolean;
9320 provided_node_features (): bigint;
9321 provided_init_features (their_node_id: number): bigint;
9325 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
9326 if(!isWasmInitialized) {
9327 throw new Error("initializeWasm() must be awaited first!");
9329 var new_obj_idx = js_objs.length;
9330 for (var i = 0; i < js_objs.length; i++) {
9331 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9333 js_objs[i] = new WeakRef(impl);
9334 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
9336 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
9338 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
9339 if(!isWasmInitialized) {
9340 throw new Error("initializeWasm() must be awaited first!");
9342 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
9343 return nativeResponseValue;
9345 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
9347 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
9348 if(!isWasmInitialized) {
9349 throw new Error("initializeWasm() must be awaited first!");
9351 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
9352 return nativeResponseValue;
9354 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
9356 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
9357 if(!isWasmInitialized) {
9358 throw new Error("initializeWasm() must be awaited first!");
9360 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
9361 return nativeResponseValue;
9363 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
9365 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
9366 if(!isWasmInitialized) {
9367 throw new Error("initializeWasm() must be awaited first!");
9369 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
9370 return nativeResponseValue;
9372 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
9374 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
9375 if(!isWasmInitialized) {
9376 throw new Error("initializeWasm() must be awaited first!");
9378 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
9379 return nativeResponseValue;
9381 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
9383 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
9384 if(!isWasmInitialized) {
9385 throw new Error("initializeWasm() must be awaited first!");
9387 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
9388 return nativeResponseValue;
9390 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
9392 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9393 if(!isWasmInitialized) {
9394 throw new Error("initializeWasm() must be awaited first!");
9396 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
9397 return nativeResponseValue;
9399 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
9401 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9402 if(!isWasmInitialized) {
9403 throw new Error("initializeWasm() must be awaited first!");
9405 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
9406 return nativeResponseValue;
9408 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
9410 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9411 if(!isWasmInitialized) {
9412 throw new Error("initializeWasm() must be awaited first!");
9414 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
9415 return nativeResponseValue;
9417 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
9419 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9420 if(!isWasmInitialized) {
9421 throw new Error("initializeWasm() must be awaited first!");
9423 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
9424 return nativeResponseValue;
9426 // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
9428 export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
9429 if(!isWasmInitialized) {
9430 throw new Error("initializeWasm() must be awaited first!");
9432 const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
9433 return nativeResponseValue;
9435 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
9437 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
9438 if(!isWasmInitialized) {
9439 throw new Error("initializeWasm() must be awaited first!");
9441 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
9442 return nativeResponseValue;
9444 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9446 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
9447 if(!isWasmInitialized) {
9448 throw new Error("initializeWasm() must be awaited first!");
9450 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
9451 return nativeResponseValue;
9454 export interface LDKOnionMessageProvider {
9455 next_onion_message_for_peer (peer_node_id: number): bigint;
9459 export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
9460 if(!isWasmInitialized) {
9461 throw new Error("initializeWasm() must be awaited first!");
9463 var new_obj_idx = js_objs.length;
9464 for (var i = 0; i < js_objs.length; i++) {
9465 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9467 js_objs[i] = new WeakRef(impl);
9468 return [wasm.TS_LDKOnionMessageProvider_new(i), i];
9470 // LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
9472 export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
9473 if(!isWasmInitialized) {
9474 throw new Error("initializeWasm() must be awaited first!");
9476 const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
9477 return nativeResponseValue;
9480 export interface LDKOnionMessageHandler {
9481 handle_onion_message (peer_node_id: number, msg: bigint): void;
9482 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
9483 peer_disconnected (their_node_id: number): void;
9484 provided_node_features (): bigint;
9485 provided_init_features (their_node_id: number): bigint;
9489 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler, OnionMessageProvider: number): [bigint, number] {
9490 if(!isWasmInitialized) {
9491 throw new Error("initializeWasm() must be awaited first!");
9493 var new_obj_idx = js_objs.length;
9494 for (var i = 0; i < js_objs.length; i++) {
9495 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9497 js_objs[i] = new WeakRef(impl);
9498 return [wasm.TS_LDKOnionMessageHandler_new(i, OnionMessageProvider), i];
9500 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
9502 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
9503 if(!isWasmInitialized) {
9504 throw new Error("initializeWasm() must be awaited first!");
9506 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
9507 // debug statements here
9509 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
9511 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
9512 if(!isWasmInitialized) {
9513 throw new Error("initializeWasm() must be awaited first!");
9515 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
9516 return nativeResponseValue;
9518 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9520 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
9521 if(!isWasmInitialized) {
9522 throw new Error("initializeWasm() must be awaited first!");
9524 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
9525 // debug statements here
9527 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
9529 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
9534 return nativeResponseValue;
9536 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9538 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
9539 if(!isWasmInitialized) {
9540 throw new Error("initializeWasm() must be awaited first!");
9542 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
9543 return nativeResponseValue;
9546 export interface LDKCustomMessageReader {
9547 read (message_type: number, buffer: number): bigint;
9551 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
9552 if(!isWasmInitialized) {
9553 throw new Error("initializeWasm() must be awaited first!");
9555 var new_obj_idx = js_objs.length;
9556 for (var i = 0; i < js_objs.length; i++) {
9557 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9559 js_objs[i] = new WeakRef(impl);
9560 return [wasm.TS_LDKCustomMessageReader_new(i), i];
9562 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
9564 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
9565 if(!isWasmInitialized) {
9566 throw new Error("initializeWasm() must be awaited first!");
9568 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
9569 return nativeResponseValue;
9572 export interface LDKCustomMessageHandler {
9573 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
9574 get_and_clear_pending_msg (): number;
9575 provided_node_features (): bigint;
9576 provided_init_features (their_node_id: number): bigint;
9580 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
9581 if(!isWasmInitialized) {
9582 throw new Error("initializeWasm() must be awaited first!");
9584 var new_obj_idx = js_objs.length;
9585 for (var i = 0; i < js_objs.length; i++) {
9586 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9588 js_objs[i] = new WeakRef(impl);
9589 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
9591 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
9593 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
9594 if(!isWasmInitialized) {
9595 throw new Error("initializeWasm() must be awaited first!");
9597 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
9598 return nativeResponseValue;
9600 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
9602 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
9603 if(!isWasmInitialized) {
9604 throw new Error("initializeWasm() must be awaited first!");
9606 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
9607 return nativeResponseValue;
9609 // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
9611 export function CustomMessageHandler_provided_node_features(this_arg: bigint): bigint {
9612 if(!isWasmInitialized) {
9613 throw new Error("initializeWasm() must be awaited first!");
9615 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_node_features(this_arg);
9616 return nativeResponseValue;
9618 // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9620 export function CustomMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
9621 if(!isWasmInitialized) {
9622 throw new Error("initializeWasm() must be awaited first!");
9624 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_init_features(this_arg, their_node_id);
9625 return nativeResponseValue;
9628 export interface LDKOffersMessageHandler {
9629 handle_message (message: bigint): bigint;
9633 export function LDKOffersMessageHandler_new(impl: LDKOffersMessageHandler): [bigint, number] {
9634 if(!isWasmInitialized) {
9635 throw new Error("initializeWasm() must be awaited first!");
9637 var new_obj_idx = js_objs.length;
9638 for (var i = 0; i < js_objs.length; i++) {
9639 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9641 js_objs[i] = new WeakRef(impl);
9642 return [wasm.TS_LDKOffersMessageHandler_new(i), i];
9644 // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
9646 export function OffersMessageHandler_handle_message(this_arg: bigint, message: bigint): bigint {
9647 if(!isWasmInitialized) {
9648 throw new Error("initializeWasm() must be awaited first!");
9650 const nativeResponseValue = wasm.TS_OffersMessageHandler_handle_message(this_arg, message);
9651 return nativeResponseValue;
9654 export interface LDKCustomOnionMessageHandler {
9655 handle_custom_message (msg: bigint): bigint;
9656 read_custom_message (message_type: bigint, buffer: number): bigint;
9660 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
9661 if(!isWasmInitialized) {
9662 throw new Error("initializeWasm() must be awaited first!");
9664 var new_obj_idx = js_objs.length;
9665 for (var i = 0; i < js_objs.length; i++) {
9666 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9668 js_objs[i] = new WeakRef(impl);
9669 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
9671 // LDKCOption_CustomOnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKCustomOnionMessageContents msg
9673 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): bigint {
9674 if(!isWasmInitialized) {
9675 throw new Error("initializeWasm() must be awaited first!");
9677 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
9678 return nativeResponseValue;
9680 // LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
9682 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
9683 if(!isWasmInitialized) {
9684 throw new Error("initializeWasm() must be awaited first!");
9686 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
9687 return nativeResponseValue;
9690 export interface LDKSocketDescriptor {
9691 send_data (data: number, resume_read: boolean): number;
9692 disconnect_socket (): void;
9693 eq (other_arg: bigint): boolean;
9698 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
9699 if(!isWasmInitialized) {
9700 throw new Error("initializeWasm() must be awaited first!");
9702 var new_obj_idx = js_objs.length;
9703 for (var i = 0; i < js_objs.length; i++) {
9704 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9706 js_objs[i] = new WeakRef(impl);
9707 return [wasm.TS_LDKSocketDescriptor_new(i), i];
9709 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
9711 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
9712 if(!isWasmInitialized) {
9713 throw new Error("initializeWasm() must be awaited first!");
9715 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
9716 return nativeResponseValue;
9718 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
9720 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
9721 if(!isWasmInitialized) {
9722 throw new Error("initializeWasm() must be awaited first!");
9724 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
9725 // debug statements here
9727 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
9729 export function SocketDescriptor_hash(this_arg: bigint): bigint {
9730 if(!isWasmInitialized) {
9731 throw new Error("initializeWasm() must be awaited first!");
9733 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
9734 return nativeResponseValue;
9737 export class LDKEffectiveCapacity {
9738 protected constructor() {}
9741 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
9742 if(!isWasmInitialized) {
9743 throw new Error("initializeWasm() must be awaited first!");
9745 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
9746 return nativeResponseValue;
9749 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
9750 if(!isWasmInitialized) {
9751 throw new Error("initializeWasm() must be awaited first!");
9753 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
9754 return nativeResponseValue;
9757 export function LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr: bigint): bigint {
9758 if(!isWasmInitialized) {
9759 throw new Error("initializeWasm() must be awaited first!");
9761 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr);
9762 return nativeResponseValue;
9765 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
9766 if(!isWasmInitialized) {
9767 throw new Error("initializeWasm() must be awaited first!");
9769 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
9770 return nativeResponseValue;
9773 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
9774 if(!isWasmInitialized) {
9775 throw new Error("initializeWasm() must be awaited first!");
9777 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
9778 return nativeResponseValue;
9781 export function LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr: bigint): bigint {
9782 if(!isWasmInitialized) {
9783 throw new Error("initializeWasm() must be awaited first!");
9785 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr);
9786 return nativeResponseValue;
9789 export class LDKPayee {
9790 protected constructor() {}
9793 export function LDKPayee_ty_from_ptr(ptr: bigint): number {
9794 if(!isWasmInitialized) {
9795 throw new Error("initializeWasm() must be awaited first!");
9797 const nativeResponseValue = wasm.TS_LDKPayee_ty_from_ptr(ptr);
9798 return nativeResponseValue;
9801 export function LDKPayee_Blinded_get_route_hints(ptr: bigint): number {
9802 if(!isWasmInitialized) {
9803 throw new Error("initializeWasm() must be awaited first!");
9805 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_route_hints(ptr);
9806 return nativeResponseValue;
9809 export function LDKPayee_Blinded_get_features(ptr: bigint): bigint {
9810 if(!isWasmInitialized) {
9811 throw new Error("initializeWasm() must be awaited first!");
9813 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_features(ptr);
9814 return nativeResponseValue;
9817 export function LDKPayee_Clear_get_node_id(ptr: bigint): number {
9818 if(!isWasmInitialized) {
9819 throw new Error("initializeWasm() must be awaited first!");
9821 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_node_id(ptr);
9822 return nativeResponseValue;
9825 export function LDKPayee_Clear_get_route_hints(ptr: bigint): number {
9826 if(!isWasmInitialized) {
9827 throw new Error("initializeWasm() must be awaited first!");
9829 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_route_hints(ptr);
9830 return nativeResponseValue;
9833 export function LDKPayee_Clear_get_features(ptr: bigint): bigint {
9834 if(!isWasmInitialized) {
9835 throw new Error("initializeWasm() must be awaited first!");
9837 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_features(ptr);
9838 return nativeResponseValue;
9841 export function LDKPayee_Clear_get_final_cltv_expiry_delta(ptr: bigint): number {
9842 if(!isWasmInitialized) {
9843 throw new Error("initializeWasm() must be awaited first!");
9845 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_final_cltv_expiry_delta(ptr);
9846 return nativeResponseValue;
9849 export class LDKDestination {
9850 protected constructor() {}
9853 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
9854 if(!isWasmInitialized) {
9855 throw new Error("initializeWasm() must be awaited first!");
9857 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
9858 return nativeResponseValue;
9861 export function LDKDestination_Node_get_node(ptr: bigint): number {
9862 if(!isWasmInitialized) {
9863 throw new Error("initializeWasm() must be awaited first!");
9865 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
9866 return nativeResponseValue;
9869 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
9870 if(!isWasmInitialized) {
9871 throw new Error("initializeWasm() must be awaited first!");
9873 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
9874 return nativeResponseValue;
9877 export interface LDKMessageRouter {
9878 find_path (sender: number, peers: number, destination: bigint): bigint;
9882 export function LDKMessageRouter_new(impl: LDKMessageRouter): [bigint, number] {
9883 if(!isWasmInitialized) {
9884 throw new Error("initializeWasm() must be awaited first!");
9886 var new_obj_idx = js_objs.length;
9887 for (var i = 0; i < js_objs.length; i++) {
9888 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9890 js_objs[i] = new WeakRef(impl);
9891 return [wasm.TS_LDKMessageRouter_new(i), i];
9893 // LDKCResult_OnionMessagePathNoneZ MessageRouter_find_path LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination
9895 export function MessageRouter_find_path(this_arg: bigint, sender: number, peers: number, destination: bigint): bigint {
9896 if(!isWasmInitialized) {
9897 throw new Error("initializeWasm() must be awaited first!");
9899 const nativeResponseValue = wasm.TS_MessageRouter_find_path(this_arg, sender, peers, destination);
9900 return nativeResponseValue;
9903 export class LDKOnionMessageContents {
9904 protected constructor() {}
9907 export function LDKOnionMessageContents_ty_from_ptr(ptr: bigint): number {
9908 if(!isWasmInitialized) {
9909 throw new Error("initializeWasm() must be awaited first!");
9911 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_ty_from_ptr(ptr);
9912 return nativeResponseValue;
9915 export function LDKOnionMessageContents_Offers_get_offers(ptr: bigint): bigint {
9916 if(!isWasmInitialized) {
9917 throw new Error("initializeWasm() must be awaited first!");
9919 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_Offers_get_offers(ptr);
9920 return nativeResponseValue;
9923 export function LDKOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
9924 if(!isWasmInitialized) {
9925 throw new Error("initializeWasm() must be awaited first!");
9927 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_Custom_get_custom(ptr);
9928 return nativeResponseValue;
9931 export interface LDKCoinSelectionSource {
9932 select_confirmed_utxos (claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint;
9933 sign_tx (tx: number): bigint;
9937 export function LDKCoinSelectionSource_new(impl: LDKCoinSelectionSource): [bigint, number] {
9938 if(!isWasmInitialized) {
9939 throw new Error("initializeWasm() must be awaited first!");
9941 var new_obj_idx = js_objs.length;
9942 for (var i = 0; i < js_objs.length; i++) {
9943 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9945 js_objs[i] = new WeakRef(impl);
9946 return [wasm.TS_LDKCoinSelectionSource_new(i), i];
9948 // LDKCResult_CoinSelectionNoneZ CoinSelectionSource_select_confirmed_utxos LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight
9950 export function CoinSelectionSource_select_confirmed_utxos(this_arg: bigint, claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint {
9951 if(!isWasmInitialized) {
9952 throw new Error("initializeWasm() must be awaited first!");
9954 const nativeResponseValue = wasm.TS_CoinSelectionSource_select_confirmed_utxos(this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
9955 return nativeResponseValue;
9957 // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_tx LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKTransaction tx
9959 export function CoinSelectionSource_sign_tx(this_arg: bigint, tx: number): bigint {
9960 if(!isWasmInitialized) {
9961 throw new Error("initializeWasm() must be awaited first!");
9963 const nativeResponseValue = wasm.TS_CoinSelectionSource_sign_tx(this_arg, tx);
9964 return nativeResponseValue;
9967 export interface LDKWalletSource {
9968 list_confirmed_utxos (): bigint;
9969 get_change_script (): bigint;
9970 sign_tx (tx: number): bigint;
9974 export function LDKWalletSource_new(impl: LDKWalletSource): [bigint, number] {
9975 if(!isWasmInitialized) {
9976 throw new Error("initializeWasm() must be awaited first!");
9978 var new_obj_idx = js_objs.length;
9979 for (var i = 0; i < js_objs.length; i++) {
9980 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9982 js_objs[i] = new WeakRef(impl);
9983 return [wasm.TS_LDKWalletSource_new(i), i];
9985 // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
9987 export function WalletSource_list_confirmed_utxos(this_arg: bigint): bigint {
9988 if(!isWasmInitialized) {
9989 throw new Error("initializeWasm() must be awaited first!");
9991 const nativeResponseValue = wasm.TS_WalletSource_list_confirmed_utxos(this_arg);
9992 return nativeResponseValue;
9994 // LDKCResult_ScriptNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
9996 export function WalletSource_get_change_script(this_arg: bigint): bigint {
9997 if(!isWasmInitialized) {
9998 throw new Error("initializeWasm() must be awaited first!");
10000 const nativeResponseValue = wasm.TS_WalletSource_get_change_script(this_arg);
10001 return nativeResponseValue;
10003 // LDKCResult_TransactionNoneZ WalletSource_sign_tx LDKWalletSource *NONNULL_PTR this_arg, struct LDKTransaction tx
10005 export function WalletSource_sign_tx(this_arg: bigint, tx: number): bigint {
10006 if(!isWasmInitialized) {
10007 throw new Error("initializeWasm() must be awaited first!");
10009 const nativeResponseValue = wasm.TS_WalletSource_sign_tx(this_arg, tx);
10010 return nativeResponseValue;
10013 export class LDKGossipSync {
10014 protected constructor() {}
10017 export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
10018 if(!isWasmInitialized) {
10019 throw new Error("initializeWasm() must be awaited first!");
10021 const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
10022 return nativeResponseValue;
10025 export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
10026 if(!isWasmInitialized) {
10027 throw new Error("initializeWasm() must be awaited first!");
10029 const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
10030 return nativeResponseValue;
10033 export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
10034 if(!isWasmInitialized) {
10035 throw new Error("initializeWasm() must be awaited first!");
10037 const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
10038 return nativeResponseValue;
10041 export class LDKFallback {
10042 protected constructor() {}
10045 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
10046 if(!isWasmInitialized) {
10047 throw new Error("initializeWasm() must be awaited first!");
10049 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
10050 return nativeResponseValue;
10053 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
10054 if(!isWasmInitialized) {
10055 throw new Error("initializeWasm() must be awaited first!");
10057 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
10058 return nativeResponseValue;
10061 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
10062 if(!isWasmInitialized) {
10063 throw new Error("initializeWasm() must be awaited first!");
10065 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
10066 return nativeResponseValue;
10069 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
10070 if(!isWasmInitialized) {
10071 throw new Error("initializeWasm() must be awaited first!");
10073 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
10074 return nativeResponseValue;
10077 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
10078 if(!isWasmInitialized) {
10079 throw new Error("initializeWasm() must be awaited first!");
10081 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
10082 return nativeResponseValue;
10084 // struct LDKStr _ldk_get_compiled_version(void);
10086 export function _ldk_get_compiled_version(): number {
10087 if(!isWasmInitialized) {
10088 throw new Error("initializeWasm() must be awaited first!");
10090 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
10091 return nativeResponseValue;
10093 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
10095 export function _ldk_c_bindings_get_compiled_version(): number {
10096 if(!isWasmInitialized) {
10097 throw new Error("initializeWasm() must be awaited first!");
10099 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
10100 return nativeResponseValue;
10102 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
10104 export function U128_le_bytes(val: number): number {
10105 if(!isWasmInitialized) {
10106 throw new Error("initializeWasm() must be awaited first!");
10108 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
10109 return nativeResponseValue;
10111 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
10113 export function U128_new(le_bytes: number): number {
10114 if(!isWasmInitialized) {
10115 throw new Error("initializeWasm() must be awaited first!");
10117 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
10118 return nativeResponseValue;
10120 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
10122 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
10123 if(!isWasmInitialized) {
10124 throw new Error("initializeWasm() must be awaited first!");
10126 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
10127 return nativeResponseValue;
10129 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
10131 export function Bech32Error_clone_ptr(arg: bigint): bigint {
10132 if(!isWasmInitialized) {
10133 throw new Error("initializeWasm() must be awaited first!");
10135 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
10136 return nativeResponseValue;
10138 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
10140 export function Bech32Error_clone(orig: bigint): bigint {
10141 if(!isWasmInitialized) {
10142 throw new Error("initializeWasm() must be awaited first!");
10144 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
10145 return nativeResponseValue;
10147 // void Bech32Error_free(struct LDKBech32Error o);
10149 export function Bech32Error_free(o: bigint): void {
10150 if(!isWasmInitialized) {
10151 throw new Error("initializeWasm() must be awaited first!");
10153 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
10154 // debug statements here
10156 // void Transaction_free(struct LDKTransaction _res);
10158 export function Transaction_free(_res: number): void {
10159 if(!isWasmInitialized) {
10160 throw new Error("initializeWasm() must be awaited first!");
10162 const nativeResponseValue = wasm.TS_Transaction_free(_res);
10163 // debug statements here
10165 // void Witness_free(struct LDKWitness _res);
10167 export function Witness_free(_res: number): void {
10168 if(!isWasmInitialized) {
10169 throw new Error("initializeWasm() must be awaited first!");
10171 const nativeResponseValue = wasm.TS_Witness_free(_res);
10172 // debug statements here
10174 // void TxIn_free(struct LDKTxIn _res);
10176 export function TxIn_free(_res: bigint): void {
10177 if(!isWasmInitialized) {
10178 throw new Error("initializeWasm() must be awaited first!");
10180 const nativeResponseValue = wasm.TS_TxIn_free(_res);
10181 // debug statements here
10183 // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
10185 export function TxIn_new(witness: number, script_sig: number, sequence: number, previous_txid: number, previous_vout: number): bigint {
10186 if(!isWasmInitialized) {
10187 throw new Error("initializeWasm() must be awaited first!");
10189 const nativeResponseValue = wasm.TS_TxIn_new(witness, script_sig, sequence, previous_txid, previous_vout);
10190 return nativeResponseValue;
10192 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
10194 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
10195 if(!isWasmInitialized) {
10196 throw new Error("initializeWasm() must be awaited first!");
10198 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
10199 return nativeResponseValue;
10201 // void TxOut_free(struct LDKTxOut _res);
10203 export function TxOut_free(_res: bigint): void {
10204 if(!isWasmInitialized) {
10205 throw new Error("initializeWasm() must be awaited first!");
10207 const nativeResponseValue = wasm.TS_TxOut_free(_res);
10208 // debug statements here
10210 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
10212 export function TxOut_clone_ptr(arg: bigint): bigint {
10213 if(!isWasmInitialized) {
10214 throw new Error("initializeWasm() must be awaited first!");
10216 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
10217 return nativeResponseValue;
10219 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
10221 export function TxOut_clone(orig: bigint): bigint {
10222 if(!isWasmInitialized) {
10223 throw new Error("initializeWasm() must be awaited first!");
10225 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
10226 return nativeResponseValue;
10228 // void Str_free(struct LDKStr _res);
10230 export function Str_free(_res: number): void {
10231 if(!isWasmInitialized) {
10232 throw new Error("initializeWasm() must be awaited first!");
10234 const nativeResponseValue = wasm.TS_Str_free(_res);
10235 // debug statements here
10237 // struct LDKCOption_DurationZ COption_DurationZ_some(uint64_t o);
10239 export function COption_DurationZ_some(o: bigint): bigint {
10240 if(!isWasmInitialized) {
10241 throw new Error("initializeWasm() must be awaited first!");
10243 const nativeResponseValue = wasm.TS_COption_DurationZ_some(o);
10244 return nativeResponseValue;
10246 // struct LDKCOption_DurationZ COption_DurationZ_none(void);
10248 export function COption_DurationZ_none(): bigint {
10249 if(!isWasmInitialized) {
10250 throw new Error("initializeWasm() must be awaited first!");
10252 const nativeResponseValue = wasm.TS_COption_DurationZ_none();
10253 return nativeResponseValue;
10255 // void COption_DurationZ_free(struct LDKCOption_DurationZ _res);
10257 export function COption_DurationZ_free(_res: bigint): void {
10258 if(!isWasmInitialized) {
10259 throw new Error("initializeWasm() must be awaited first!");
10261 const nativeResponseValue = wasm.TS_COption_DurationZ_free(_res);
10262 // debug statements here
10264 // uint64_t COption_DurationZ_clone_ptr(LDKCOption_DurationZ *NONNULL_PTR arg);
10266 export function COption_DurationZ_clone_ptr(arg: bigint): bigint {
10267 if(!isWasmInitialized) {
10268 throw new Error("initializeWasm() must be awaited first!");
10270 const nativeResponseValue = wasm.TS_COption_DurationZ_clone_ptr(arg);
10271 return nativeResponseValue;
10273 // struct LDKCOption_DurationZ COption_DurationZ_clone(const struct LDKCOption_DurationZ *NONNULL_PTR orig);
10275 export function COption_DurationZ_clone(orig: bigint): bigint {
10276 if(!isWasmInitialized) {
10277 throw new Error("initializeWasm() must be awaited first!");
10279 const nativeResponseValue = wasm.TS_COption_DurationZ_clone(orig);
10280 return nativeResponseValue;
10282 // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
10284 export function CVec_BlindedPathZ_free(_res: number): void {
10285 if(!isWasmInitialized) {
10286 throw new Error("initializeWasm() must be awaited first!");
10288 const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
10289 // debug statements here
10291 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
10293 export function COption_u64Z_some(o: bigint): bigint {
10294 if(!isWasmInitialized) {
10295 throw new Error("initializeWasm() must be awaited first!");
10297 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
10298 return nativeResponseValue;
10300 // struct LDKCOption_u64Z COption_u64Z_none(void);
10302 export function COption_u64Z_none(): bigint {
10303 if(!isWasmInitialized) {
10304 throw new Error("initializeWasm() must be awaited first!");
10306 const nativeResponseValue = wasm.TS_COption_u64Z_none();
10307 return nativeResponseValue;
10309 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
10311 export function COption_u64Z_free(_res: bigint): void {
10312 if(!isWasmInitialized) {
10313 throw new Error("initializeWasm() must be awaited first!");
10315 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
10316 // debug statements here
10318 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
10320 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
10321 if(!isWasmInitialized) {
10322 throw new Error("initializeWasm() must be awaited first!");
10324 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
10325 return nativeResponseValue;
10327 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
10329 export function COption_u64Z_clone(orig: bigint): bigint {
10330 if(!isWasmInitialized) {
10331 throw new Error("initializeWasm() must be awaited first!");
10333 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
10334 return nativeResponseValue;
10336 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
10338 export function CResult_RefundBolt12ParseErrorZ_ok(o: bigint): bigint {
10339 if(!isWasmInitialized) {
10340 throw new Error("initializeWasm() must be awaited first!");
10342 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_ok(o);
10343 return nativeResponseValue;
10345 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
10347 export function CResult_RefundBolt12ParseErrorZ_err(e: bigint): bigint {
10348 if(!isWasmInitialized) {
10349 throw new Error("initializeWasm() must be awaited first!");
10351 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_err(e);
10352 return nativeResponseValue;
10354 // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
10356 export function CResult_RefundBolt12ParseErrorZ_is_ok(o: bigint): boolean {
10357 if(!isWasmInitialized) {
10358 throw new Error("initializeWasm() must be awaited first!");
10360 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_is_ok(o);
10361 return nativeResponseValue;
10363 // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
10365 export function CResult_RefundBolt12ParseErrorZ_free(_res: bigint): void {
10366 if(!isWasmInitialized) {
10367 throw new Error("initializeWasm() must be awaited first!");
10369 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_free(_res);
10370 // debug statements here
10372 // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
10374 export function CResult_RefundBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
10375 if(!isWasmInitialized) {
10376 throw new Error("initializeWasm() must be awaited first!");
10378 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(arg);
10379 return nativeResponseValue;
10381 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
10383 export function CResult_RefundBolt12ParseErrorZ_clone(orig: bigint): bigint {
10384 if(!isWasmInitialized) {
10385 throw new Error("initializeWasm() must be awaited first!");
10387 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone(orig);
10388 return nativeResponseValue;
10390 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10392 export function CResult_NoneAPIErrorZ_ok(): bigint {
10393 if(!isWasmInitialized) {
10394 throw new Error("initializeWasm() must be awaited first!");
10396 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10397 return nativeResponseValue;
10399 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10401 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
10402 if(!isWasmInitialized) {
10403 throw new Error("initializeWasm() must be awaited first!");
10405 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10406 return nativeResponseValue;
10408 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10410 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
10411 if(!isWasmInitialized) {
10412 throw new Error("initializeWasm() must be awaited first!");
10414 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10415 return nativeResponseValue;
10417 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10419 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
10420 if(!isWasmInitialized) {
10421 throw new Error("initializeWasm() must be awaited first!");
10423 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
10424 // debug statements here
10426 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
10428 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
10429 if(!isWasmInitialized) {
10430 throw new Error("initializeWasm() must be awaited first!");
10432 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
10433 return nativeResponseValue;
10435 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
10437 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
10438 if(!isWasmInitialized) {
10439 throw new Error("initializeWasm() must be awaited first!");
10441 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
10442 return nativeResponseValue;
10444 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
10446 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
10447 if(!isWasmInitialized) {
10448 throw new Error("initializeWasm() must be awaited first!");
10450 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
10451 // debug statements here
10453 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
10455 export function CVec_APIErrorZ_free(_res: number): void {
10456 if(!isWasmInitialized) {
10457 throw new Error("initializeWasm() must be awaited first!");
10459 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
10460 // debug statements here
10462 // struct LDKCOption_PaymentSecretZ COption_PaymentSecretZ_some(struct LDKThirtyTwoBytes o);
10464 export function COption_PaymentSecretZ_some(o: number): bigint {
10465 if(!isWasmInitialized) {
10466 throw new Error("initializeWasm() must be awaited first!");
10468 const nativeResponseValue = wasm.TS_COption_PaymentSecretZ_some(o);
10469 return nativeResponseValue;
10471 // struct LDKCOption_PaymentSecretZ COption_PaymentSecretZ_none(void);
10473 export function COption_PaymentSecretZ_none(): bigint {
10474 if(!isWasmInitialized) {
10475 throw new Error("initializeWasm() must be awaited first!");
10477 const nativeResponseValue = wasm.TS_COption_PaymentSecretZ_none();
10478 return nativeResponseValue;
10480 // void COption_PaymentSecretZ_free(struct LDKCOption_PaymentSecretZ _res);
10482 export function COption_PaymentSecretZ_free(_res: bigint): void {
10483 if(!isWasmInitialized) {
10484 throw new Error("initializeWasm() must be awaited first!");
10486 const nativeResponseValue = wasm.TS_COption_PaymentSecretZ_free(_res);
10487 // debug statements here
10489 // uint64_t COption_PaymentSecretZ_clone_ptr(LDKCOption_PaymentSecretZ *NONNULL_PTR arg);
10491 export function COption_PaymentSecretZ_clone_ptr(arg: bigint): bigint {
10492 if(!isWasmInitialized) {
10493 throw new Error("initializeWasm() must be awaited first!");
10495 const nativeResponseValue = wasm.TS_COption_PaymentSecretZ_clone_ptr(arg);
10496 return nativeResponseValue;
10498 // struct LDKCOption_PaymentSecretZ COption_PaymentSecretZ_clone(const struct LDKCOption_PaymentSecretZ *NONNULL_PTR orig);
10500 export function COption_PaymentSecretZ_clone(orig: bigint): bigint {
10501 if(!isWasmInitialized) {
10502 throw new Error("initializeWasm() must be awaited first!");
10504 const nativeResponseValue = wasm.TS_COption_PaymentSecretZ_clone(orig);
10505 return nativeResponseValue;
10507 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10509 export function CVec_u8Z_free(_res: number): void {
10510 if(!isWasmInitialized) {
10511 throw new Error("initializeWasm() must be awaited first!");
10513 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10514 // debug statements here
10516 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
10518 export function COption_CVec_u8ZZ_some(o: number): bigint {
10519 if(!isWasmInitialized) {
10520 throw new Error("initializeWasm() must be awaited first!");
10522 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
10523 return nativeResponseValue;
10525 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
10527 export function COption_CVec_u8ZZ_none(): bigint {
10528 if(!isWasmInitialized) {
10529 throw new Error("initializeWasm() must be awaited first!");
10531 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
10532 return nativeResponseValue;
10534 // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
10536 export function COption_CVec_u8ZZ_free(_res: bigint): void {
10537 if(!isWasmInitialized) {
10538 throw new Error("initializeWasm() must be awaited first!");
10540 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
10541 // debug statements here
10543 // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
10545 export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
10546 if(!isWasmInitialized) {
10547 throw new Error("initializeWasm() must be awaited first!");
10549 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
10550 return nativeResponseValue;
10552 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
10554 export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
10555 if(!isWasmInitialized) {
10556 throw new Error("initializeWasm() must be awaited first!");
10558 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
10559 return nativeResponseValue;
10561 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
10563 export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
10564 if(!isWasmInitialized) {
10565 throw new Error("initializeWasm() must be awaited first!");
10567 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
10568 return nativeResponseValue;
10570 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
10572 export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
10573 if(!isWasmInitialized) {
10574 throw new Error("initializeWasm() must be awaited first!");
10576 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
10577 return nativeResponseValue;
10579 // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
10581 export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
10582 if(!isWasmInitialized) {
10583 throw new Error("initializeWasm() must be awaited first!");
10585 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
10586 return nativeResponseValue;
10588 // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
10590 export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
10591 if(!isWasmInitialized) {
10592 throw new Error("initializeWasm() must be awaited first!");
10594 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
10595 // debug statements here
10597 // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
10599 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10600 if(!isWasmInitialized) {
10601 throw new Error("initializeWasm() must be awaited first!");
10603 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
10604 return nativeResponseValue;
10606 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
10608 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
10609 if(!isWasmInitialized) {
10610 throw new Error("initializeWasm() must be awaited first!");
10612 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
10613 return nativeResponseValue;
10615 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_some(struct LDKOffersMessage o);
10617 export function COption_OffersMessageZ_some(o: bigint): bigint {
10618 if(!isWasmInitialized) {
10619 throw new Error("initializeWasm() must be awaited first!");
10621 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_some(o);
10622 return nativeResponseValue;
10624 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_none(void);
10626 export function COption_OffersMessageZ_none(): bigint {
10627 if(!isWasmInitialized) {
10628 throw new Error("initializeWasm() must be awaited first!");
10630 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_none();
10631 return nativeResponseValue;
10633 // void COption_OffersMessageZ_free(struct LDKCOption_OffersMessageZ _res);
10635 export function COption_OffersMessageZ_free(_res: bigint): void {
10636 if(!isWasmInitialized) {
10637 throw new Error("initializeWasm() must be awaited first!");
10639 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_free(_res);
10640 // debug statements here
10642 // uint64_t COption_OffersMessageZ_clone_ptr(LDKCOption_OffersMessageZ *NONNULL_PTR arg);
10644 export function COption_OffersMessageZ_clone_ptr(arg: bigint): bigint {
10645 if(!isWasmInitialized) {
10646 throw new Error("initializeWasm() must be awaited first!");
10648 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone_ptr(arg);
10649 return nativeResponseValue;
10651 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_clone(const struct LDKCOption_OffersMessageZ *NONNULL_PTR orig);
10653 export function COption_OffersMessageZ_clone(orig: bigint): bigint {
10654 if(!isWasmInitialized) {
10655 throw new Error("initializeWasm() must be awaited first!");
10657 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone(orig);
10658 return nativeResponseValue;
10660 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_ok(struct LDKOffersMessage o);
10662 export function CResult_OffersMessageDecodeErrorZ_ok(o: bigint): bigint {
10663 if(!isWasmInitialized) {
10664 throw new Error("initializeWasm() must be awaited first!");
10666 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_ok(o);
10667 return nativeResponseValue;
10669 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_err(struct LDKDecodeError e);
10671 export function CResult_OffersMessageDecodeErrorZ_err(e: bigint): bigint {
10672 if(!isWasmInitialized) {
10673 throw new Error("initializeWasm() must be awaited first!");
10675 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_err(e);
10676 return nativeResponseValue;
10678 // bool CResult_OffersMessageDecodeErrorZ_is_ok(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR o);
10680 export function CResult_OffersMessageDecodeErrorZ_is_ok(o: bigint): boolean {
10681 if(!isWasmInitialized) {
10682 throw new Error("initializeWasm() must be awaited first!");
10684 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_is_ok(o);
10685 return nativeResponseValue;
10687 // void CResult_OffersMessageDecodeErrorZ_free(struct LDKCResult_OffersMessageDecodeErrorZ _res);
10689 export function CResult_OffersMessageDecodeErrorZ_free(_res: bigint): void {
10690 if(!isWasmInitialized) {
10691 throw new Error("initializeWasm() must be awaited first!");
10693 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_free(_res);
10694 // debug statements here
10696 // uint64_t CResult_OffersMessageDecodeErrorZ_clone_ptr(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR arg);
10698 export function CResult_OffersMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10699 if(!isWasmInitialized) {
10700 throw new Error("initializeWasm() must be awaited first!");
10702 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone_ptr(arg);
10703 return nativeResponseValue;
10705 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_clone(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR orig);
10707 export function CResult_OffersMessageDecodeErrorZ_clone(orig: bigint): bigint {
10708 if(!isWasmInitialized) {
10709 throw new Error("initializeWasm() must be awaited first!");
10711 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone(orig);
10712 return nativeResponseValue;
10714 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
10716 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
10717 if(!isWasmInitialized) {
10718 throw new Error("initializeWasm() must be awaited first!");
10720 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
10721 return nativeResponseValue;
10723 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
10725 export function COption_HTLCClaimZ_none(): bigint {
10726 if(!isWasmInitialized) {
10727 throw new Error("initializeWasm() must be awaited first!");
10729 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
10730 return nativeResponseValue;
10732 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
10734 export function COption_HTLCClaimZ_free(_res: bigint): void {
10735 if(!isWasmInitialized) {
10736 throw new Error("initializeWasm() must be awaited first!");
10738 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
10739 // debug statements here
10741 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
10743 export function CResult_NoneNoneZ_ok(): bigint {
10744 if(!isWasmInitialized) {
10745 throw new Error("initializeWasm() must be awaited first!");
10747 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
10748 return nativeResponseValue;
10750 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
10752 export function CResult_NoneNoneZ_err(): bigint {
10753 if(!isWasmInitialized) {
10754 throw new Error("initializeWasm() must be awaited first!");
10756 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
10757 return nativeResponseValue;
10759 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
10761 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
10762 if(!isWasmInitialized) {
10763 throw new Error("initializeWasm() must be awaited first!");
10765 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
10766 return nativeResponseValue;
10768 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
10770 export function CResult_NoneNoneZ_free(_res: bigint): void {
10771 if(!isWasmInitialized) {
10772 throw new Error("initializeWasm() must be awaited first!");
10774 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
10775 // debug statements here
10777 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
10779 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
10780 if(!isWasmInitialized) {
10781 throw new Error("initializeWasm() must be awaited first!");
10783 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
10784 return nativeResponseValue;
10786 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
10788 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
10789 if(!isWasmInitialized) {
10790 throw new Error("initializeWasm() must be awaited first!");
10792 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
10793 return nativeResponseValue;
10795 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
10797 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
10798 if(!isWasmInitialized) {
10799 throw new Error("initializeWasm() must be awaited first!");
10801 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
10802 return nativeResponseValue;
10804 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
10806 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
10807 if(!isWasmInitialized) {
10808 throw new Error("initializeWasm() must be awaited first!");
10810 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
10811 return nativeResponseValue;
10813 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
10815 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
10816 if(!isWasmInitialized) {
10817 throw new Error("initializeWasm() must be awaited first!");
10819 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
10820 return nativeResponseValue;
10822 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
10824 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
10825 if(!isWasmInitialized) {
10826 throw new Error("initializeWasm() must be awaited first!");
10828 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
10829 // debug statements here
10831 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
10833 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10834 if(!isWasmInitialized) {
10835 throw new Error("initializeWasm() must be awaited first!");
10837 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
10838 return nativeResponseValue;
10840 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
10842 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
10843 if(!isWasmInitialized) {
10844 throw new Error("initializeWasm() must be awaited first!");
10846 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
10847 return nativeResponseValue;
10849 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
10851 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
10852 if(!isWasmInitialized) {
10853 throw new Error("initializeWasm() must be awaited first!");
10855 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
10856 return nativeResponseValue;
10858 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
10860 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
10861 if(!isWasmInitialized) {
10862 throw new Error("initializeWasm() must be awaited first!");
10864 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
10865 return nativeResponseValue;
10867 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
10869 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
10870 if(!isWasmInitialized) {
10871 throw new Error("initializeWasm() must be awaited first!");
10873 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
10874 return nativeResponseValue;
10876 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
10878 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
10879 if(!isWasmInitialized) {
10880 throw new Error("initializeWasm() must be awaited first!");
10882 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
10883 // debug statements here
10885 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
10887 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10888 if(!isWasmInitialized) {
10889 throw new Error("initializeWasm() must be awaited first!");
10891 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
10892 return nativeResponseValue;
10894 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
10896 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
10897 if(!isWasmInitialized) {
10898 throw new Error("initializeWasm() must be awaited first!");
10900 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
10901 return nativeResponseValue;
10903 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
10905 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
10906 if(!isWasmInitialized) {
10907 throw new Error("initializeWasm() must be awaited first!");
10909 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
10910 return nativeResponseValue;
10912 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
10914 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
10915 if(!isWasmInitialized) {
10916 throw new Error("initializeWasm() must be awaited first!");
10918 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
10919 return nativeResponseValue;
10921 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
10923 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
10924 if(!isWasmInitialized) {
10925 throw new Error("initializeWasm() must be awaited first!");
10927 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
10928 return nativeResponseValue;
10930 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
10932 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
10933 if(!isWasmInitialized) {
10934 throw new Error("initializeWasm() must be awaited first!");
10936 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
10937 // debug statements here
10939 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
10941 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10942 if(!isWasmInitialized) {
10943 throw new Error("initializeWasm() must be awaited first!");
10945 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
10946 return nativeResponseValue;
10948 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
10950 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
10951 if(!isWasmInitialized) {
10952 throw new Error("initializeWasm() must be awaited first!");
10954 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
10955 return nativeResponseValue;
10957 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
10959 export function COption_u32Z_some(o: number): bigint {
10960 if(!isWasmInitialized) {
10961 throw new Error("initializeWasm() must be awaited first!");
10963 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
10964 return nativeResponseValue;
10966 // struct LDKCOption_u32Z COption_u32Z_none(void);
10968 export function COption_u32Z_none(): bigint {
10969 if(!isWasmInitialized) {
10970 throw new Error("initializeWasm() must be awaited first!");
10972 const nativeResponseValue = wasm.TS_COption_u32Z_none();
10973 return nativeResponseValue;
10975 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
10977 export function COption_u32Z_free(_res: bigint): void {
10978 if(!isWasmInitialized) {
10979 throw new Error("initializeWasm() must be awaited first!");
10981 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
10982 // debug statements here
10984 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
10986 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
10987 if(!isWasmInitialized) {
10988 throw new Error("initializeWasm() must be awaited first!");
10990 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
10991 return nativeResponseValue;
10993 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
10995 export function COption_u32Z_clone(orig: bigint): bigint {
10996 if(!isWasmInitialized) {
10997 throw new Error("initializeWasm() must be awaited first!");
10999 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
11000 return nativeResponseValue;
11002 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
11004 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
11005 if(!isWasmInitialized) {
11006 throw new Error("initializeWasm() must be awaited first!");
11008 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
11009 return nativeResponseValue;
11011 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
11013 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
11014 if(!isWasmInitialized) {
11015 throw new Error("initializeWasm() must be awaited first!");
11017 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
11018 return nativeResponseValue;
11020 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
11022 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
11023 if(!isWasmInitialized) {
11024 throw new Error("initializeWasm() must be awaited first!");
11026 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
11027 return nativeResponseValue;
11029 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
11031 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
11032 if(!isWasmInitialized) {
11033 throw new Error("initializeWasm() must be awaited first!");
11035 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
11036 // debug statements here
11038 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
11040 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11041 if(!isWasmInitialized) {
11042 throw new Error("initializeWasm() must be awaited first!");
11044 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
11045 return nativeResponseValue;
11047 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
11049 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
11050 if(!isWasmInitialized) {
11051 throw new Error("initializeWasm() must be awaited first!");
11053 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
11054 return nativeResponseValue;
11056 // struct LDKCOption_PaymentPreimageZ COption_PaymentPreimageZ_some(struct LDKThirtyTwoBytes o);
11058 export function COption_PaymentPreimageZ_some(o: number): bigint {
11059 if(!isWasmInitialized) {
11060 throw new Error("initializeWasm() must be awaited first!");
11062 const nativeResponseValue = wasm.TS_COption_PaymentPreimageZ_some(o);
11063 return nativeResponseValue;
11065 // struct LDKCOption_PaymentPreimageZ COption_PaymentPreimageZ_none(void);
11067 export function COption_PaymentPreimageZ_none(): bigint {
11068 if(!isWasmInitialized) {
11069 throw new Error("initializeWasm() must be awaited first!");
11071 const nativeResponseValue = wasm.TS_COption_PaymentPreimageZ_none();
11072 return nativeResponseValue;
11074 // void COption_PaymentPreimageZ_free(struct LDKCOption_PaymentPreimageZ _res);
11076 export function COption_PaymentPreimageZ_free(_res: bigint): void {
11077 if(!isWasmInitialized) {
11078 throw new Error("initializeWasm() must be awaited first!");
11080 const nativeResponseValue = wasm.TS_COption_PaymentPreimageZ_free(_res);
11081 // debug statements here
11083 // uint64_t COption_PaymentPreimageZ_clone_ptr(LDKCOption_PaymentPreimageZ *NONNULL_PTR arg);
11085 export function COption_PaymentPreimageZ_clone_ptr(arg: bigint): bigint {
11086 if(!isWasmInitialized) {
11087 throw new Error("initializeWasm() must be awaited first!");
11089 const nativeResponseValue = wasm.TS_COption_PaymentPreimageZ_clone_ptr(arg);
11090 return nativeResponseValue;
11092 // struct LDKCOption_PaymentPreimageZ COption_PaymentPreimageZ_clone(const struct LDKCOption_PaymentPreimageZ *NONNULL_PTR orig);
11094 export function COption_PaymentPreimageZ_clone(orig: bigint): bigint {
11095 if(!isWasmInitialized) {
11096 throw new Error("initializeWasm() must be awaited first!");
11098 const nativeResponseValue = wasm.TS_COption_PaymentPreimageZ_clone(orig);
11099 return nativeResponseValue;
11101 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
11103 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
11104 if(!isWasmInitialized) {
11105 throw new Error("initializeWasm() must be awaited first!");
11107 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
11108 return nativeResponseValue;
11110 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
11112 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
11113 if(!isWasmInitialized) {
11114 throw new Error("initializeWasm() must be awaited first!");
11116 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
11117 return nativeResponseValue;
11119 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
11121 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
11122 if(!isWasmInitialized) {
11123 throw new Error("initializeWasm() must be awaited first!");
11125 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
11126 return nativeResponseValue;
11128 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
11130 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
11131 if(!isWasmInitialized) {
11132 throw new Error("initializeWasm() must be awaited first!");
11134 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
11135 // debug statements here
11137 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
11139 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11140 if(!isWasmInitialized) {
11141 throw new Error("initializeWasm() must be awaited first!");
11143 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
11144 return nativeResponseValue;
11146 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
11148 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
11149 if(!isWasmInitialized) {
11150 throw new Error("initializeWasm() must be awaited first!");
11152 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
11153 return nativeResponseValue;
11155 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
11157 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
11158 if(!isWasmInitialized) {
11159 throw new Error("initializeWasm() must be awaited first!");
11161 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
11162 return nativeResponseValue;
11164 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
11166 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
11167 if(!isWasmInitialized) {
11168 throw new Error("initializeWasm() must be awaited first!");
11170 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
11171 return nativeResponseValue;
11173 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
11175 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
11176 if(!isWasmInitialized) {
11177 throw new Error("initializeWasm() must be awaited first!");
11179 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
11180 return nativeResponseValue;
11182 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
11184 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
11185 if(!isWasmInitialized) {
11186 throw new Error("initializeWasm() must be awaited first!");
11188 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
11189 // debug statements here
11191 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
11193 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11194 if(!isWasmInitialized) {
11195 throw new Error("initializeWasm() must be awaited first!");
11197 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
11198 return nativeResponseValue;
11200 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
11202 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
11203 if(!isWasmInitialized) {
11204 throw new Error("initializeWasm() must be awaited first!");
11206 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
11207 return nativeResponseValue;
11209 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
11211 export function CVec_SignatureZ_free(_res: number): void {
11212 if(!isWasmInitialized) {
11213 throw new Error("initializeWasm() must be awaited first!");
11215 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
11216 // debug statements here
11218 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
11220 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
11221 if(!isWasmInitialized) {
11222 throw new Error("initializeWasm() must be awaited first!");
11224 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
11225 return nativeResponseValue;
11227 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
11229 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
11230 if(!isWasmInitialized) {
11231 throw new Error("initializeWasm() must be awaited first!");
11233 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
11234 return nativeResponseValue;
11236 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
11238 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
11239 if(!isWasmInitialized) {
11240 throw new Error("initializeWasm() must be awaited first!");
11242 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
11243 return nativeResponseValue;
11245 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
11247 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
11248 if(!isWasmInitialized) {
11249 throw new Error("initializeWasm() must be awaited first!");
11251 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
11252 // debug statements here
11254 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
11256 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11257 if(!isWasmInitialized) {
11258 throw new Error("initializeWasm() must be awaited first!");
11260 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
11261 return nativeResponseValue;
11263 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
11265 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
11266 if(!isWasmInitialized) {
11267 throw new Error("initializeWasm() must be awaited first!");
11269 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
11270 return nativeResponseValue;
11272 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
11274 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
11275 if(!isWasmInitialized) {
11276 throw new Error("initializeWasm() must be awaited first!");
11278 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
11279 return nativeResponseValue;
11281 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
11283 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
11284 if(!isWasmInitialized) {
11285 throw new Error("initializeWasm() must be awaited first!");
11287 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
11288 return nativeResponseValue;
11290 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
11292 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
11293 if(!isWasmInitialized) {
11294 throw new Error("initializeWasm() must be awaited first!");
11296 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
11297 return nativeResponseValue;
11299 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
11301 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
11302 if(!isWasmInitialized) {
11303 throw new Error("initializeWasm() must be awaited first!");
11305 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
11306 // debug statements here
11308 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
11310 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11311 if(!isWasmInitialized) {
11312 throw new Error("initializeWasm() must be awaited first!");
11314 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
11315 return nativeResponseValue;
11317 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
11319 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
11320 if(!isWasmInitialized) {
11321 throw new Error("initializeWasm() must be awaited first!");
11323 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
11324 return nativeResponseValue;
11326 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
11328 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
11329 if(!isWasmInitialized) {
11330 throw new Error("initializeWasm() must be awaited first!");
11332 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
11333 return nativeResponseValue;
11335 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
11337 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
11338 if(!isWasmInitialized) {
11339 throw new Error("initializeWasm() must be awaited first!");
11341 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
11342 return nativeResponseValue;
11344 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
11346 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
11347 if(!isWasmInitialized) {
11348 throw new Error("initializeWasm() must be awaited first!");
11350 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
11351 return nativeResponseValue;
11353 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
11355 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
11356 if(!isWasmInitialized) {
11357 throw new Error("initializeWasm() must be awaited first!");
11359 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
11360 // debug statements here
11362 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
11364 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
11365 if(!isWasmInitialized) {
11366 throw new Error("initializeWasm() must be awaited first!");
11368 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
11369 return nativeResponseValue;
11371 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
11373 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
11374 if(!isWasmInitialized) {
11375 throw new Error("initializeWasm() must be awaited first!");
11377 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
11378 return nativeResponseValue;
11380 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
11382 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
11383 if(!isWasmInitialized) {
11384 throw new Error("initializeWasm() must be awaited first!");
11386 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
11387 return nativeResponseValue;
11389 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
11391 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
11392 if(!isWasmInitialized) {
11393 throw new Error("initializeWasm() must be awaited first!");
11395 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
11396 // debug statements here
11398 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
11400 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11401 if(!isWasmInitialized) {
11402 throw new Error("initializeWasm() must be awaited first!");
11404 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
11405 return nativeResponseValue;
11407 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
11409 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
11410 if(!isWasmInitialized) {
11411 throw new Error("initializeWasm() must be awaited first!");
11413 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
11414 return nativeResponseValue;
11416 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
11418 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
11419 if(!isWasmInitialized) {
11420 throw new Error("initializeWasm() must be awaited first!");
11422 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
11423 return nativeResponseValue;
11425 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
11427 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
11428 if(!isWasmInitialized) {
11429 throw new Error("initializeWasm() must be awaited first!");
11431 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
11432 return nativeResponseValue;
11434 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
11436 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
11437 if(!isWasmInitialized) {
11438 throw new Error("initializeWasm() must be awaited first!");
11440 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
11441 return nativeResponseValue;
11443 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
11445 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
11446 if(!isWasmInitialized) {
11447 throw new Error("initializeWasm() must be awaited first!");
11449 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
11450 // debug statements here
11452 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
11454 export function CResult_CVec_SignatureZNoneZ_ok(o: number): bigint {
11455 if(!isWasmInitialized) {
11456 throw new Error("initializeWasm() must be awaited first!");
11458 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
11459 return nativeResponseValue;
11461 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
11463 export function CResult_CVec_SignatureZNoneZ_err(): bigint {
11464 if(!isWasmInitialized) {
11465 throw new Error("initializeWasm() must be awaited first!");
11467 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
11468 return nativeResponseValue;
11470 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
11472 export function CResult_CVec_SignatureZNoneZ_is_ok(o: bigint): boolean {
11473 if(!isWasmInitialized) {
11474 throw new Error("initializeWasm() must be awaited first!");
11476 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
11477 return nativeResponseValue;
11479 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
11481 export function CResult_CVec_SignatureZNoneZ_free(_res: bigint): void {
11482 if(!isWasmInitialized) {
11483 throw new Error("initializeWasm() must be awaited first!");
11485 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
11486 // debug statements here
11488 // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
11490 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: bigint): bigint {
11491 if(!isWasmInitialized) {
11492 throw new Error("initializeWasm() must be awaited first!");
11494 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
11495 return nativeResponseValue;
11497 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
11499 export function CResult_CVec_SignatureZNoneZ_clone(orig: bigint): bigint {
11500 if(!isWasmInitialized) {
11501 throw new Error("initializeWasm() must be awaited first!");
11503 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
11504 return nativeResponseValue;
11506 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
11508 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
11509 if(!isWasmInitialized) {
11510 throw new Error("initializeWasm() must be awaited first!");
11512 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
11513 return nativeResponseValue;
11515 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
11517 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
11518 if(!isWasmInitialized) {
11519 throw new Error("initializeWasm() must be awaited first!");
11521 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
11522 return nativeResponseValue;
11524 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
11526 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
11527 if(!isWasmInitialized) {
11528 throw new Error("initializeWasm() must be awaited first!");
11530 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
11531 return nativeResponseValue;
11533 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
11535 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
11536 if(!isWasmInitialized) {
11537 throw new Error("initializeWasm() must be awaited first!");
11539 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
11540 // debug statements here
11542 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
11544 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11545 if(!isWasmInitialized) {
11546 throw new Error("initializeWasm() must be awaited first!");
11548 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
11549 return nativeResponseValue;
11551 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
11553 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
11554 if(!isWasmInitialized) {
11555 throw new Error("initializeWasm() must be awaited first!");
11557 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
11558 return nativeResponseValue;
11560 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
11562 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
11563 if(!isWasmInitialized) {
11564 throw new Error("initializeWasm() must be awaited first!");
11566 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
11567 return nativeResponseValue;
11569 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
11571 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
11572 if(!isWasmInitialized) {
11573 throw new Error("initializeWasm() must be awaited first!");
11575 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
11576 return nativeResponseValue;
11578 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
11580 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
11581 if(!isWasmInitialized) {
11582 throw new Error("initializeWasm() must be awaited first!");
11584 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
11585 return nativeResponseValue;
11587 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
11589 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
11590 if(!isWasmInitialized) {
11591 throw new Error("initializeWasm() must be awaited first!");
11593 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
11594 // debug statements here
11596 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
11598 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
11599 if(!isWasmInitialized) {
11600 throw new Error("initializeWasm() must be awaited first!");
11602 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
11603 return nativeResponseValue;
11605 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
11607 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
11608 if(!isWasmInitialized) {
11609 throw new Error("initializeWasm() must be awaited first!");
11611 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
11612 return nativeResponseValue;
11614 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
11616 export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
11617 if(!isWasmInitialized) {
11618 throw new Error("initializeWasm() must be awaited first!");
11620 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
11621 return nativeResponseValue;
11623 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
11625 export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
11626 if(!isWasmInitialized) {
11627 throw new Error("initializeWasm() must be awaited first!");
11629 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
11630 return nativeResponseValue;
11632 // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
11634 export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11635 if(!isWasmInitialized) {
11636 throw new Error("initializeWasm() must be awaited first!");
11638 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
11639 return nativeResponseValue;
11641 // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
11643 export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
11644 if(!isWasmInitialized) {
11645 throw new Error("initializeWasm() must be awaited first!");
11647 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
11648 // debug statements here
11650 // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
11652 export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11653 if(!isWasmInitialized) {
11654 throw new Error("initializeWasm() must be awaited first!");
11656 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
11657 return nativeResponseValue;
11659 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
11661 export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
11662 if(!isWasmInitialized) {
11663 throw new Error("initializeWasm() must be awaited first!");
11665 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
11666 return nativeResponseValue;
11668 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
11670 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11671 if(!isWasmInitialized) {
11672 throw new Error("initializeWasm() must be awaited first!");
11674 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
11675 return nativeResponseValue;
11677 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11679 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11680 if(!isWasmInitialized) {
11681 throw new Error("initializeWasm() must be awaited first!");
11683 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
11684 return nativeResponseValue;
11686 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11688 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11689 if(!isWasmInitialized) {
11690 throw new Error("initializeWasm() must be awaited first!");
11692 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11693 return nativeResponseValue;
11695 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
11697 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11698 if(!isWasmInitialized) {
11699 throw new Error("initializeWasm() must be awaited first!");
11701 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
11702 // debug statements here
11704 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11706 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11707 if(!isWasmInitialized) {
11708 throw new Error("initializeWasm() must be awaited first!");
11710 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11711 return nativeResponseValue;
11713 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11715 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11716 if(!isWasmInitialized) {
11717 throw new Error("initializeWasm() must be awaited first!");
11719 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11720 return nativeResponseValue;
11722 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
11724 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11725 if(!isWasmInitialized) {
11726 throw new Error("initializeWasm() must be awaited first!");
11728 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
11729 return nativeResponseValue;
11731 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11733 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11734 if(!isWasmInitialized) {
11735 throw new Error("initializeWasm() must be awaited first!");
11737 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
11738 return nativeResponseValue;
11740 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11742 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11743 if(!isWasmInitialized) {
11744 throw new Error("initializeWasm() must be awaited first!");
11746 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11747 return nativeResponseValue;
11749 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
11751 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11752 if(!isWasmInitialized) {
11753 throw new Error("initializeWasm() must be awaited first!");
11755 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
11756 // debug statements here
11758 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11760 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11761 if(!isWasmInitialized) {
11762 throw new Error("initializeWasm() must be awaited first!");
11764 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11765 return nativeResponseValue;
11767 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11769 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11770 if(!isWasmInitialized) {
11771 throw new Error("initializeWasm() must be awaited first!");
11773 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11774 return nativeResponseValue;
11776 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
11778 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11779 if(!isWasmInitialized) {
11780 throw new Error("initializeWasm() must be awaited first!");
11782 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
11783 return nativeResponseValue;
11785 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11787 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11788 if(!isWasmInitialized) {
11789 throw new Error("initializeWasm() must be awaited first!");
11791 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
11792 return nativeResponseValue;
11794 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11796 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11797 if(!isWasmInitialized) {
11798 throw new Error("initializeWasm() must be awaited first!");
11800 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
11801 return nativeResponseValue;
11803 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
11805 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11806 if(!isWasmInitialized) {
11807 throw new Error("initializeWasm() must be awaited first!");
11809 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
11810 // debug statements here
11812 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11814 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11815 if(!isWasmInitialized) {
11816 throw new Error("initializeWasm() must be awaited first!");
11818 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11819 return nativeResponseValue;
11821 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11823 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11824 if(!isWasmInitialized) {
11825 throw new Error("initializeWasm() must be awaited first!");
11827 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
11828 return nativeResponseValue;
11830 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
11832 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
11833 if(!isWasmInitialized) {
11834 throw new Error("initializeWasm() must be awaited first!");
11836 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
11837 // debug statements here
11839 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11841 export function CVec_TxOutZ_free(_res: number): void {
11842 if(!isWasmInitialized) {
11843 throw new Error("initializeWasm() must be awaited first!");
11845 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11846 // debug statements here
11848 // struct LDKCOption_PackedLockTimeZ COption_PackedLockTimeZ_some(uint32_t o);
11850 export function COption_PackedLockTimeZ_some(o: number): bigint {
11851 if(!isWasmInitialized) {
11852 throw new Error("initializeWasm() must be awaited first!");
11854 const nativeResponseValue = wasm.TS_COption_PackedLockTimeZ_some(o);
11855 return nativeResponseValue;
11857 // struct LDKCOption_PackedLockTimeZ COption_PackedLockTimeZ_none(void);
11859 export function COption_PackedLockTimeZ_none(): bigint {
11860 if(!isWasmInitialized) {
11861 throw new Error("initializeWasm() must be awaited first!");
11863 const nativeResponseValue = wasm.TS_COption_PackedLockTimeZ_none();
11864 return nativeResponseValue;
11866 // void COption_PackedLockTimeZ_free(struct LDKCOption_PackedLockTimeZ _res);
11868 export function COption_PackedLockTimeZ_free(_res: bigint): void {
11869 if(!isWasmInitialized) {
11870 throw new Error("initializeWasm() must be awaited first!");
11872 const nativeResponseValue = wasm.TS_COption_PackedLockTimeZ_free(_res);
11873 // debug statements here
11875 // uint64_t COption_PackedLockTimeZ_clone_ptr(LDKCOption_PackedLockTimeZ *NONNULL_PTR arg);
11877 export function COption_PackedLockTimeZ_clone_ptr(arg: bigint): bigint {
11878 if(!isWasmInitialized) {
11879 throw new Error("initializeWasm() must be awaited first!");
11881 const nativeResponseValue = wasm.TS_COption_PackedLockTimeZ_clone_ptr(arg);
11882 return nativeResponseValue;
11884 // struct LDKCOption_PackedLockTimeZ COption_PackedLockTimeZ_clone(const struct LDKCOption_PackedLockTimeZ *NONNULL_PTR orig);
11886 export function COption_PackedLockTimeZ_clone(orig: bigint): bigint {
11887 if(!isWasmInitialized) {
11888 throw new Error("initializeWasm() must be awaited first!");
11890 const nativeResponseValue = wasm.TS_COption_PackedLockTimeZ_clone(orig);
11891 return nativeResponseValue;
11893 // uint64_t C2Tuple_PartiallySignedTransactionusizeZ_clone_ptr(LDKC2Tuple_PartiallySignedTransactionusizeZ *NONNULL_PTR arg);
11895 export function C2Tuple_PartiallySignedTransactionusizeZ_clone_ptr(arg: bigint): bigint {
11896 if(!isWasmInitialized) {
11897 throw new Error("initializeWasm() must be awaited first!");
11899 const nativeResponseValue = wasm.TS_C2Tuple_PartiallySignedTransactionusizeZ_clone_ptr(arg);
11900 return nativeResponseValue;
11902 // struct LDKC2Tuple_PartiallySignedTransactionusizeZ C2Tuple_PartiallySignedTransactionusizeZ_clone(const struct LDKC2Tuple_PartiallySignedTransactionusizeZ *NONNULL_PTR orig);
11904 export function C2Tuple_PartiallySignedTransactionusizeZ_clone(orig: bigint): bigint {
11905 if(!isWasmInitialized) {
11906 throw new Error("initializeWasm() must be awaited first!");
11908 const nativeResponseValue = wasm.TS_C2Tuple_PartiallySignedTransactionusizeZ_clone(orig);
11909 return nativeResponseValue;
11911 // struct LDKC2Tuple_PartiallySignedTransactionusizeZ C2Tuple_PartiallySignedTransactionusizeZ_new(struct LDKCVec_u8Z a, uintptr_t b);
11913 export function C2Tuple_PartiallySignedTransactionusizeZ_new(a: number, b: number): bigint {
11914 if(!isWasmInitialized) {
11915 throw new Error("initializeWasm() must be awaited first!");
11917 const nativeResponseValue = wasm.TS_C2Tuple_PartiallySignedTransactionusizeZ_new(a, b);
11918 return nativeResponseValue;
11920 // void C2Tuple_PartiallySignedTransactionusizeZ_free(struct LDKC2Tuple_PartiallySignedTransactionusizeZ _res);
11922 export function C2Tuple_PartiallySignedTransactionusizeZ_free(_res: bigint): void {
11923 if(!isWasmInitialized) {
11924 throw new Error("initializeWasm() must be awaited first!");
11926 const nativeResponseValue = wasm.TS_C2Tuple_PartiallySignedTransactionusizeZ_free(_res);
11927 // debug statements here
11929 // struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_ok(struct LDKC2Tuple_PartiallySignedTransactionusizeZ o);
11931 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_ok(o: bigint): bigint {
11932 if(!isWasmInitialized) {
11933 throw new Error("initializeWasm() must be awaited first!");
11935 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_ok(o);
11936 return nativeResponseValue;
11938 // struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_err(void);
11940 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_err(): bigint {
11941 if(!isWasmInitialized) {
11942 throw new Error("initializeWasm() must be awaited first!");
11944 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_err();
11945 return nativeResponseValue;
11947 // bool CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ *NONNULL_PTR o);
11949 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_is_ok(o: bigint): boolean {
11950 if(!isWasmInitialized) {
11951 throw new Error("initializeWasm() must be awaited first!");
11953 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_is_ok(o);
11954 return nativeResponseValue;
11956 // void CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_free(struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ _res);
11958 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_free(_res: bigint): void {
11959 if(!isWasmInitialized) {
11960 throw new Error("initializeWasm() must be awaited first!");
11962 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_free(_res);
11963 // debug statements here
11965 // uint64_t CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_clone_ptr(LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ *NONNULL_PTR arg);
11967 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_clone_ptr(arg: bigint): bigint {
11968 if(!isWasmInitialized) {
11969 throw new Error("initializeWasm() must be awaited first!");
11971 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_clone_ptr(arg);
11972 return nativeResponseValue;
11974 // struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_clone(const struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ *NONNULL_PTR orig);
11976 export function CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_clone(orig: bigint): bigint {
11977 if(!isWasmInitialized) {
11978 throw new Error("initializeWasm() must be awaited first!");
11980 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ_clone(orig);
11981 return nativeResponseValue;
11983 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
11985 export function CVec_PaymentPreimageZ_free(_res: number): void {
11986 if(!isWasmInitialized) {
11987 throw new Error("initializeWasm() must be awaited first!");
11989 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
11990 // debug statements here
11992 // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
11994 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: bigint): bigint {
11995 if(!isWasmInitialized) {
11996 throw new Error("initializeWasm() must be awaited first!");
11998 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
11999 return nativeResponseValue;
12001 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
12003 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: bigint): bigint {
12004 if(!isWasmInitialized) {
12005 throw new Error("initializeWasm() must be awaited first!");
12007 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
12008 return nativeResponseValue;
12010 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
12012 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): bigint {
12013 if(!isWasmInitialized) {
12014 throw new Error("initializeWasm() must be awaited first!");
12016 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
12017 return nativeResponseValue;
12019 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
12021 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: bigint): void {
12022 if(!isWasmInitialized) {
12023 throw new Error("initializeWasm() must be awaited first!");
12025 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
12026 // debug statements here
12028 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
12030 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: bigint): bigint {
12031 if(!isWasmInitialized) {
12032 throw new Error("initializeWasm() must be awaited first!");
12034 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
12035 return nativeResponseValue;
12037 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
12039 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): bigint {
12040 if(!isWasmInitialized) {
12041 throw new Error("initializeWasm() must be awaited first!");
12043 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
12044 return nativeResponseValue;
12046 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
12048 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: bigint): boolean {
12049 if(!isWasmInitialized) {
12050 throw new Error("initializeWasm() must be awaited first!");
12052 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
12053 return nativeResponseValue;
12055 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
12057 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: bigint): void {
12058 if(!isWasmInitialized) {
12059 throw new Error("initializeWasm() must be awaited first!");
12061 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
12062 // debug statements here
12064 // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
12066 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
12067 if(!isWasmInitialized) {
12068 throw new Error("initializeWasm() must be awaited first!");
12070 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
12071 return nativeResponseValue;
12073 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
12075 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: bigint): bigint {
12076 if(!isWasmInitialized) {
12077 throw new Error("initializeWasm() must be awaited first!");
12079 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
12080 return nativeResponseValue;
12082 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
12084 export function CResult_SignatureNoneZ_ok(o: number): bigint {
12085 if(!isWasmInitialized) {
12086 throw new Error("initializeWasm() must be awaited first!");
12088 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
12089 return nativeResponseValue;
12091 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
12093 export function CResult_SignatureNoneZ_err(): bigint {
12094 if(!isWasmInitialized) {
12095 throw new Error("initializeWasm() must be awaited first!");
12097 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
12098 return nativeResponseValue;
12100 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
12102 export function CResult_SignatureNoneZ_is_ok(o: bigint): boolean {
12103 if(!isWasmInitialized) {
12104 throw new Error("initializeWasm() must be awaited first!");
12106 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
12107 return nativeResponseValue;
12109 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
12111 export function CResult_SignatureNoneZ_free(_res: bigint): void {
12112 if(!isWasmInitialized) {
12113 throw new Error("initializeWasm() must be awaited first!");
12115 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
12116 // debug statements here
12118 // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
12120 export function CResult_SignatureNoneZ_clone_ptr(arg: bigint): bigint {
12121 if(!isWasmInitialized) {
12122 throw new Error("initializeWasm() must be awaited first!");
12124 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
12125 return nativeResponseValue;
12127 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
12129 export function CResult_SignatureNoneZ_clone(orig: bigint): bigint {
12130 if(!isWasmInitialized) {
12131 throw new Error("initializeWasm() must be awaited first!");
12133 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
12134 return nativeResponseValue;
12136 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
12138 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
12139 if(!isWasmInitialized) {
12140 throw new Error("initializeWasm() must be awaited first!");
12142 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
12143 return nativeResponseValue;
12145 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
12147 export function CResult_PublicKeyNoneZ_err(): bigint {
12148 if(!isWasmInitialized) {
12149 throw new Error("initializeWasm() must be awaited first!");
12151 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
12152 return nativeResponseValue;
12154 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
12156 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
12157 if(!isWasmInitialized) {
12158 throw new Error("initializeWasm() must be awaited first!");
12160 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
12161 return nativeResponseValue;
12163 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
12165 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
12166 if(!isWasmInitialized) {
12167 throw new Error("initializeWasm() must be awaited first!");
12169 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
12170 // debug statements here
12172 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
12174 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
12175 if(!isWasmInitialized) {
12176 throw new Error("initializeWasm() must be awaited first!");
12178 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
12179 return nativeResponseValue;
12181 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
12183 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
12184 if(!isWasmInitialized) {
12185 throw new Error("initializeWasm() must be awaited first!");
12187 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
12188 return nativeResponseValue;
12190 // struct LDKCOption_ScalarZ COption_ScalarZ_some(struct LDKBigEndianScalar o);
12192 export function COption_ScalarZ_some(o: bigint): bigint {
12193 if(!isWasmInitialized) {
12194 throw new Error("initializeWasm() must be awaited first!");
12196 const nativeResponseValue = wasm.TS_COption_ScalarZ_some(o);
12197 return nativeResponseValue;
12199 // struct LDKCOption_ScalarZ COption_ScalarZ_none(void);
12201 export function COption_ScalarZ_none(): bigint {
12202 if(!isWasmInitialized) {
12203 throw new Error("initializeWasm() must be awaited first!");
12205 const nativeResponseValue = wasm.TS_COption_ScalarZ_none();
12206 return nativeResponseValue;
12208 // void COption_ScalarZ_free(struct LDKCOption_ScalarZ _res);
12210 export function COption_ScalarZ_free(_res: bigint): void {
12211 if(!isWasmInitialized) {
12212 throw new Error("initializeWasm() must be awaited first!");
12214 const nativeResponseValue = wasm.TS_COption_ScalarZ_free(_res);
12215 // debug statements here
12217 // uint64_t COption_ScalarZ_clone_ptr(LDKCOption_ScalarZ *NONNULL_PTR arg);
12219 export function COption_ScalarZ_clone_ptr(arg: bigint): bigint {
12220 if(!isWasmInitialized) {
12221 throw new Error("initializeWasm() must be awaited first!");
12223 const nativeResponseValue = wasm.TS_COption_ScalarZ_clone_ptr(arg);
12224 return nativeResponseValue;
12226 // struct LDKCOption_ScalarZ COption_ScalarZ_clone(const struct LDKCOption_ScalarZ *NONNULL_PTR orig);
12228 export function COption_ScalarZ_clone(orig: bigint): bigint {
12229 if(!isWasmInitialized) {
12230 throw new Error("initializeWasm() must be awaited first!");
12232 const nativeResponseValue = wasm.TS_COption_ScalarZ_clone(orig);
12233 return nativeResponseValue;
12235 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12237 export function CResult_SharedSecretNoneZ_ok(o: number): bigint {
12238 if(!isWasmInitialized) {
12239 throw new Error("initializeWasm() must be awaited first!");
12241 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_ok(o);
12242 return nativeResponseValue;
12244 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_err(void);
12246 export function CResult_SharedSecretNoneZ_err(): bigint {
12247 if(!isWasmInitialized) {
12248 throw new Error("initializeWasm() must be awaited first!");
12250 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_err();
12251 return nativeResponseValue;
12253 // bool CResult_SharedSecretNoneZ_is_ok(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR o);
12255 export function CResult_SharedSecretNoneZ_is_ok(o: bigint): boolean {
12256 if(!isWasmInitialized) {
12257 throw new Error("initializeWasm() must be awaited first!");
12259 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_is_ok(o);
12260 return nativeResponseValue;
12262 // void CResult_SharedSecretNoneZ_free(struct LDKCResult_SharedSecretNoneZ _res);
12264 export function CResult_SharedSecretNoneZ_free(_res: bigint): void {
12265 if(!isWasmInitialized) {
12266 throw new Error("initializeWasm() must be awaited first!");
12268 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_free(_res);
12269 // debug statements here
12271 // uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg);
12273 export function CResult_SharedSecretNoneZ_clone_ptr(arg: bigint): bigint {
12274 if(!isWasmInitialized) {
12275 throw new Error("initializeWasm() must be awaited first!");
12277 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone_ptr(arg);
12278 return nativeResponseValue;
12280 // struct LDKCResult_SharedSecretNoneZ CResult_SharedSecretNoneZ_clone(const struct LDKCResult_SharedSecretNoneZ *NONNULL_PTR orig);
12282 export function CResult_SharedSecretNoneZ_clone(orig: bigint): bigint {
12283 if(!isWasmInitialized) {
12284 throw new Error("initializeWasm() must be awaited first!");
12286 const nativeResponseValue = wasm.TS_CResult_SharedSecretNoneZ_clone(orig);
12287 return nativeResponseValue;
12289 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
12291 export function CVec_U5Z_free(_res: number): void {
12292 if(!isWasmInitialized) {
12293 throw new Error("initializeWasm() must be awaited first!");
12295 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
12296 // debug statements here
12298 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
12300 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
12301 if(!isWasmInitialized) {
12302 throw new Error("initializeWasm() must be awaited first!");
12304 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
12305 return nativeResponseValue;
12307 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
12309 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
12310 if(!isWasmInitialized) {
12311 throw new Error("initializeWasm() must be awaited first!");
12313 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
12314 return nativeResponseValue;
12316 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
12318 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
12319 if(!isWasmInitialized) {
12320 throw new Error("initializeWasm() must be awaited first!");
12322 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
12323 return nativeResponseValue;
12325 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
12327 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
12328 if(!isWasmInitialized) {
12329 throw new Error("initializeWasm() must be awaited first!");
12331 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
12332 // debug statements here
12334 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
12336 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12337 if(!isWasmInitialized) {
12338 throw new Error("initializeWasm() must be awaited first!");
12340 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
12341 return nativeResponseValue;
12343 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
12345 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
12346 if(!isWasmInitialized) {
12347 throw new Error("initializeWasm() must be awaited first!");
12349 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
12350 return nativeResponseValue;
12352 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
12354 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
12355 if(!isWasmInitialized) {
12356 throw new Error("initializeWasm() must be awaited first!");
12358 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
12359 return nativeResponseValue;
12361 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
12363 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
12364 if(!isWasmInitialized) {
12365 throw new Error("initializeWasm() must be awaited first!");
12367 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
12368 return nativeResponseValue;
12370 // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
12372 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
12373 if(!isWasmInitialized) {
12374 throw new Error("initializeWasm() must be awaited first!");
12376 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
12377 return nativeResponseValue;
12379 // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
12381 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
12382 if(!isWasmInitialized) {
12383 throw new Error("initializeWasm() must be awaited first!");
12385 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
12386 // debug statements here
12388 // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
12390 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12391 if(!isWasmInitialized) {
12392 throw new Error("initializeWasm() must be awaited first!");
12394 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
12395 return nativeResponseValue;
12397 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
12399 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
12400 if(!isWasmInitialized) {
12401 throw new Error("initializeWasm() must be awaited first!");
12403 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
12404 return nativeResponseValue;
12406 // struct LDKCResult_ScriptNoneZ CResult_ScriptNoneZ_ok(struct LDKCVec_u8Z o);
12408 export function CResult_ScriptNoneZ_ok(o: number): bigint {
12409 if(!isWasmInitialized) {
12410 throw new Error("initializeWasm() must be awaited first!");
12412 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_ok(o);
12413 return nativeResponseValue;
12415 // struct LDKCResult_ScriptNoneZ CResult_ScriptNoneZ_err(void);
12417 export function CResult_ScriptNoneZ_err(): bigint {
12418 if(!isWasmInitialized) {
12419 throw new Error("initializeWasm() must be awaited first!");
12421 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_err();
12422 return nativeResponseValue;
12424 // bool CResult_ScriptNoneZ_is_ok(const struct LDKCResult_ScriptNoneZ *NONNULL_PTR o);
12426 export function CResult_ScriptNoneZ_is_ok(o: bigint): boolean {
12427 if(!isWasmInitialized) {
12428 throw new Error("initializeWasm() must be awaited first!");
12430 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_is_ok(o);
12431 return nativeResponseValue;
12433 // void CResult_ScriptNoneZ_free(struct LDKCResult_ScriptNoneZ _res);
12435 export function CResult_ScriptNoneZ_free(_res: bigint): void {
12436 if(!isWasmInitialized) {
12437 throw new Error("initializeWasm() must be awaited first!");
12439 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_free(_res);
12440 // debug statements here
12442 // uint64_t CResult_ScriptNoneZ_clone_ptr(LDKCResult_ScriptNoneZ *NONNULL_PTR arg);
12444 export function CResult_ScriptNoneZ_clone_ptr(arg: bigint): bigint {
12445 if(!isWasmInitialized) {
12446 throw new Error("initializeWasm() must be awaited first!");
12448 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_clone_ptr(arg);
12449 return nativeResponseValue;
12451 // struct LDKCResult_ScriptNoneZ CResult_ScriptNoneZ_clone(const struct LDKCResult_ScriptNoneZ *NONNULL_PTR orig);
12453 export function CResult_ScriptNoneZ_clone(orig: bigint): bigint {
12454 if(!isWasmInitialized) {
12455 throw new Error("initializeWasm() must be awaited first!");
12457 const nativeResponseValue = wasm.TS_CResult_ScriptNoneZ_clone(orig);
12458 return nativeResponseValue;
12460 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
12462 export function CResult_ShutdownScriptNoneZ_ok(o: bigint): bigint {
12463 if(!isWasmInitialized) {
12464 throw new Error("initializeWasm() must be awaited first!");
12466 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_ok(o);
12467 return nativeResponseValue;
12469 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
12471 export function CResult_ShutdownScriptNoneZ_err(): bigint {
12472 if(!isWasmInitialized) {
12473 throw new Error("initializeWasm() must be awaited first!");
12475 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_err();
12476 return nativeResponseValue;
12478 // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
12480 export function CResult_ShutdownScriptNoneZ_is_ok(o: bigint): boolean {
12481 if(!isWasmInitialized) {
12482 throw new Error("initializeWasm() must be awaited first!");
12484 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_is_ok(o);
12485 return nativeResponseValue;
12487 // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
12489 export function CResult_ShutdownScriptNoneZ_free(_res: bigint): void {
12490 if(!isWasmInitialized) {
12491 throw new Error("initializeWasm() must be awaited first!");
12493 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_free(_res);
12494 // debug statements here
12496 // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
12498 export function CResult_ShutdownScriptNoneZ_clone_ptr(arg: bigint): bigint {
12499 if(!isWasmInitialized) {
12500 throw new Error("initializeWasm() must be awaited first!");
12502 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone_ptr(arg);
12503 return nativeResponseValue;
12505 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
12507 export function CResult_ShutdownScriptNoneZ_clone(orig: bigint): bigint {
12508 if(!isWasmInitialized) {
12509 throw new Error("initializeWasm() must be awaited first!");
12511 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone(orig);
12512 return nativeResponseValue;
12514 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
12516 export function CVec_CVec_u8ZZ_free(_res: number): void {
12517 if(!isWasmInitialized) {
12518 throw new Error("initializeWasm() must be awaited first!");
12520 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
12521 // debug statements here
12523 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
12525 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
12526 if(!isWasmInitialized) {
12527 throw new Error("initializeWasm() must be awaited first!");
12529 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
12530 return nativeResponseValue;
12532 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
12534 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
12535 if(!isWasmInitialized) {
12536 throw new Error("initializeWasm() must be awaited first!");
12538 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
12539 return nativeResponseValue;
12541 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
12543 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
12544 if(!isWasmInitialized) {
12545 throw new Error("initializeWasm() must be awaited first!");
12547 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
12548 return nativeResponseValue;
12550 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
12552 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
12553 if(!isWasmInitialized) {
12554 throw new Error("initializeWasm() must be awaited first!");
12556 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
12557 // debug statements here
12559 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
12561 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
12562 if(!isWasmInitialized) {
12563 throw new Error("initializeWasm() must be awaited first!");
12565 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
12566 return nativeResponseValue;
12568 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
12570 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
12571 if(!isWasmInitialized) {
12572 throw new Error("initializeWasm() must be awaited first!");
12574 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
12575 return nativeResponseValue;
12577 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
12579 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
12580 if(!isWasmInitialized) {
12581 throw new Error("initializeWasm() must be awaited first!");
12583 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
12584 return nativeResponseValue;
12586 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
12588 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
12589 if(!isWasmInitialized) {
12590 throw new Error("initializeWasm() must be awaited first!");
12592 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
12593 return nativeResponseValue;
12595 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
12597 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
12598 if(!isWasmInitialized) {
12599 throw new Error("initializeWasm() must be awaited first!");
12601 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
12602 return nativeResponseValue;
12604 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
12606 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
12607 if(!isWasmInitialized) {
12608 throw new Error("initializeWasm() must be awaited first!");
12610 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
12611 // debug statements here
12613 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
12615 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12616 if(!isWasmInitialized) {
12617 throw new Error("initializeWasm() must be awaited first!");
12619 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
12620 return nativeResponseValue;
12622 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
12624 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
12625 if(!isWasmInitialized) {
12626 throw new Error("initializeWasm() must be awaited first!");
12628 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
12629 return nativeResponseValue;
12631 // struct LDKCResult_PartiallySignedTransactionNoneZ CResult_PartiallySignedTransactionNoneZ_ok(struct LDKCVec_u8Z o);
12633 export function CResult_PartiallySignedTransactionNoneZ_ok(o: number): bigint {
12634 if(!isWasmInitialized) {
12635 throw new Error("initializeWasm() must be awaited first!");
12637 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_ok(o);
12638 return nativeResponseValue;
12640 // struct LDKCResult_PartiallySignedTransactionNoneZ CResult_PartiallySignedTransactionNoneZ_err(void);
12642 export function CResult_PartiallySignedTransactionNoneZ_err(): bigint {
12643 if(!isWasmInitialized) {
12644 throw new Error("initializeWasm() must be awaited first!");
12646 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_err();
12647 return nativeResponseValue;
12649 // bool CResult_PartiallySignedTransactionNoneZ_is_ok(const struct LDKCResult_PartiallySignedTransactionNoneZ *NONNULL_PTR o);
12651 export function CResult_PartiallySignedTransactionNoneZ_is_ok(o: bigint): boolean {
12652 if(!isWasmInitialized) {
12653 throw new Error("initializeWasm() must be awaited first!");
12655 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_is_ok(o);
12656 return nativeResponseValue;
12658 // void CResult_PartiallySignedTransactionNoneZ_free(struct LDKCResult_PartiallySignedTransactionNoneZ _res);
12660 export function CResult_PartiallySignedTransactionNoneZ_free(_res: bigint): void {
12661 if(!isWasmInitialized) {
12662 throw new Error("initializeWasm() must be awaited first!");
12664 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_free(_res);
12665 // debug statements here
12667 // uint64_t CResult_PartiallySignedTransactionNoneZ_clone_ptr(LDKCResult_PartiallySignedTransactionNoneZ *NONNULL_PTR arg);
12669 export function CResult_PartiallySignedTransactionNoneZ_clone_ptr(arg: bigint): bigint {
12670 if(!isWasmInitialized) {
12671 throw new Error("initializeWasm() must be awaited first!");
12673 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_clone_ptr(arg);
12674 return nativeResponseValue;
12676 // struct LDKCResult_PartiallySignedTransactionNoneZ CResult_PartiallySignedTransactionNoneZ_clone(const struct LDKCResult_PartiallySignedTransactionNoneZ *NONNULL_PTR orig);
12678 export function CResult_PartiallySignedTransactionNoneZ_clone(orig: bigint): bigint {
12679 if(!isWasmInitialized) {
12680 throw new Error("initializeWasm() must be awaited first!");
12682 const nativeResponseValue = wasm.TS_CResult_PartiallySignedTransactionNoneZ_clone(orig);
12683 return nativeResponseValue;
12685 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
12687 export function CResult_TransactionNoneZ_ok(o: number): bigint {
12688 if(!isWasmInitialized) {
12689 throw new Error("initializeWasm() must be awaited first!");
12691 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
12692 return nativeResponseValue;
12694 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
12696 export function CResult_TransactionNoneZ_err(): bigint {
12697 if(!isWasmInitialized) {
12698 throw new Error("initializeWasm() must be awaited first!");
12700 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
12701 return nativeResponseValue;
12703 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
12705 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
12706 if(!isWasmInitialized) {
12707 throw new Error("initializeWasm() must be awaited first!");
12709 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
12710 return nativeResponseValue;
12712 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
12714 export function CResult_TransactionNoneZ_free(_res: bigint): void {
12715 if(!isWasmInitialized) {
12716 throw new Error("initializeWasm() must be awaited first!");
12718 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
12719 // debug statements here
12721 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
12723 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
12724 if(!isWasmInitialized) {
12725 throw new Error("initializeWasm() must be awaited first!");
12727 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
12728 return nativeResponseValue;
12730 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
12732 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
12733 if(!isWasmInitialized) {
12734 throw new Error("initializeWasm() must be awaited first!");
12736 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
12737 return nativeResponseValue;
12739 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
12741 export function CVec_ChannelDetailsZ_free(_res: number): void {
12742 if(!isWasmInitialized) {
12743 throw new Error("initializeWasm() must be awaited first!");
12745 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
12746 // debug statements here
12748 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
12750 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
12751 if(!isWasmInitialized) {
12752 throw new Error("initializeWasm() must be awaited first!");
12754 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
12755 return nativeResponseValue;
12757 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
12759 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
12760 if(!isWasmInitialized) {
12761 throw new Error("initializeWasm() must be awaited first!");
12763 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
12764 return nativeResponseValue;
12766 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
12768 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
12769 if(!isWasmInitialized) {
12770 throw new Error("initializeWasm() must be awaited first!");
12772 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
12773 return nativeResponseValue;
12775 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
12777 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
12778 if(!isWasmInitialized) {
12779 throw new Error("initializeWasm() must be awaited first!");
12781 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
12782 // debug statements here
12784 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
12786 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
12787 if(!isWasmInitialized) {
12788 throw new Error("initializeWasm() must be awaited first!");
12790 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
12791 return nativeResponseValue;
12793 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
12795 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
12796 if(!isWasmInitialized) {
12797 throw new Error("initializeWasm() must be awaited first!");
12799 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
12800 return nativeResponseValue;
12802 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
12804 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
12805 if(!isWasmInitialized) {
12806 throw new Error("initializeWasm() must be awaited first!");
12808 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
12809 return nativeResponseValue;
12811 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
12813 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
12814 if(!isWasmInitialized) {
12815 throw new Error("initializeWasm() must be awaited first!");
12817 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
12818 return nativeResponseValue;
12820 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
12822 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
12823 if(!isWasmInitialized) {
12824 throw new Error("initializeWasm() must be awaited first!");
12826 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
12827 return nativeResponseValue;
12829 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
12831 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
12832 if(!isWasmInitialized) {
12833 throw new Error("initializeWasm() must be awaited first!");
12835 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
12836 // debug statements here
12838 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
12840 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12841 if(!isWasmInitialized) {
12842 throw new Error("initializeWasm() must be awaited first!");
12844 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
12845 return nativeResponseValue;
12847 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
12849 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
12850 if(!isWasmInitialized) {
12851 throw new Error("initializeWasm() must be awaited first!");
12853 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
12854 return nativeResponseValue;
12856 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
12858 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
12859 if(!isWasmInitialized) {
12860 throw new Error("initializeWasm() must be awaited first!");
12862 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
12863 return nativeResponseValue;
12865 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
12867 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
12868 if(!isWasmInitialized) {
12869 throw new Error("initializeWasm() must be awaited first!");
12871 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
12872 return nativeResponseValue;
12874 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
12876 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
12877 if(!isWasmInitialized) {
12878 throw new Error("initializeWasm() must be awaited first!");
12880 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
12881 return nativeResponseValue;
12883 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
12885 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
12886 if(!isWasmInitialized) {
12887 throw new Error("initializeWasm() must be awaited first!");
12889 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
12890 // debug statements here
12892 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
12894 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12895 if(!isWasmInitialized) {
12896 throw new Error("initializeWasm() must be awaited first!");
12898 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
12899 return nativeResponseValue;
12901 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
12903 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
12904 if(!isWasmInitialized) {
12905 throw new Error("initializeWasm() must be awaited first!");
12907 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
12908 return nativeResponseValue;
12910 // void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
12912 export function CVec_BlindedHopZ_free(_res: number): void {
12913 if(!isWasmInitialized) {
12914 throw new Error("initializeWasm() must be awaited first!");
12916 const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
12917 // debug statements here
12919 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
12921 export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
12922 if(!isWasmInitialized) {
12923 throw new Error("initializeWasm() must be awaited first!");
12925 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
12926 return nativeResponseValue;
12928 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
12930 export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
12931 if(!isWasmInitialized) {
12932 throw new Error("initializeWasm() must be awaited first!");
12934 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
12935 return nativeResponseValue;
12937 // bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
12939 export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
12940 if(!isWasmInitialized) {
12941 throw new Error("initializeWasm() must be awaited first!");
12943 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
12944 return nativeResponseValue;
12946 // void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
12948 export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
12949 if(!isWasmInitialized) {
12950 throw new Error("initializeWasm() must be awaited first!");
12952 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
12953 // debug statements here
12955 // uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
12957 export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12958 if(!isWasmInitialized) {
12959 throw new Error("initializeWasm() must be awaited first!");
12961 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
12962 return nativeResponseValue;
12964 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
12966 export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
12967 if(!isWasmInitialized) {
12968 throw new Error("initializeWasm() must be awaited first!");
12970 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
12971 return nativeResponseValue;
12973 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
12975 export function CVec_RouteHopZ_free(_res: number): void {
12976 if(!isWasmInitialized) {
12977 throw new Error("initializeWasm() must be awaited first!");
12979 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
12980 // debug statements here
12982 // void CVec_PathZ_free(struct LDKCVec_PathZ _res);
12984 export function CVec_PathZ_free(_res: number): void {
12985 if(!isWasmInitialized) {
12986 throw new Error("initializeWasm() must be awaited first!");
12988 const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
12989 // debug statements here
12991 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
12993 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
12994 if(!isWasmInitialized) {
12995 throw new Error("initializeWasm() must be awaited first!");
12997 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
12998 return nativeResponseValue;
13000 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
13002 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
13003 if(!isWasmInitialized) {
13004 throw new Error("initializeWasm() must be awaited first!");
13006 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
13007 return nativeResponseValue;
13009 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
13011 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
13012 if(!isWasmInitialized) {
13013 throw new Error("initializeWasm() must be awaited first!");
13015 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
13016 return nativeResponseValue;
13018 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
13020 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
13021 if(!isWasmInitialized) {
13022 throw new Error("initializeWasm() must be awaited first!");
13024 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
13025 // debug statements here
13027 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
13029 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13030 if(!isWasmInitialized) {
13031 throw new Error("initializeWasm() must be awaited first!");
13033 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
13034 return nativeResponseValue;
13036 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
13038 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
13039 if(!isWasmInitialized) {
13040 throw new Error("initializeWasm() must be awaited first!");
13042 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
13043 return nativeResponseValue;
13045 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
13047 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
13048 if(!isWasmInitialized) {
13049 throw new Error("initializeWasm() must be awaited first!");
13051 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
13052 return nativeResponseValue;
13054 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
13056 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
13057 if(!isWasmInitialized) {
13058 throw new Error("initializeWasm() must be awaited first!");
13060 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
13061 return nativeResponseValue;
13063 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
13065 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
13066 if(!isWasmInitialized) {
13067 throw new Error("initializeWasm() must be awaited first!");
13069 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
13070 return nativeResponseValue;
13072 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
13074 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
13075 if(!isWasmInitialized) {
13076 throw new Error("initializeWasm() must be awaited first!");
13078 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
13079 // debug statements here
13081 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
13083 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13084 if(!isWasmInitialized) {
13085 throw new Error("initializeWasm() must be awaited first!");
13087 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
13088 return nativeResponseValue;
13090 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
13092 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
13093 if(!isWasmInitialized) {
13094 throw new Error("initializeWasm() must be awaited first!");
13096 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
13097 return nativeResponseValue;
13099 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
13101 export function CVec_u64Z_free(_res: number): void {
13102 if(!isWasmInitialized) {
13103 throw new Error("initializeWasm() must be awaited first!");
13105 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
13106 // debug statements here
13108 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
13110 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
13111 if(!isWasmInitialized) {
13112 throw new Error("initializeWasm() must be awaited first!");
13114 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
13115 return nativeResponseValue;
13117 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
13119 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
13120 if(!isWasmInitialized) {
13121 throw new Error("initializeWasm() must be awaited first!");
13123 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
13124 return nativeResponseValue;
13126 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
13128 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
13129 if(!isWasmInitialized) {
13130 throw new Error("initializeWasm() must be awaited first!");
13132 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
13133 return nativeResponseValue;
13135 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
13137 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
13138 if(!isWasmInitialized) {
13139 throw new Error("initializeWasm() must be awaited first!");
13141 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
13142 // debug statements here
13144 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
13146 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13147 if(!isWasmInitialized) {
13148 throw new Error("initializeWasm() must be awaited first!");
13150 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
13151 return nativeResponseValue;
13153 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
13155 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
13156 if(!isWasmInitialized) {
13157 throw new Error("initializeWasm() must be awaited first!");
13159 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
13160 return nativeResponseValue;
13162 // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
13164 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
13165 if(!isWasmInitialized) {
13166 throw new Error("initializeWasm() must be awaited first!");
13168 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
13169 return nativeResponseValue;
13171 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
13173 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
13174 if(!isWasmInitialized) {
13175 throw new Error("initializeWasm() must be awaited first!");
13177 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
13178 return nativeResponseValue;
13180 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
13182 export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
13183 if(!isWasmInitialized) {
13184 throw new Error("initializeWasm() must be awaited first!");
13186 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
13187 return nativeResponseValue;
13189 // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
13191 export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
13192 if(!isWasmInitialized) {
13193 throw new Error("initializeWasm() must be awaited first!");
13195 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
13196 // debug statements here
13198 // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
13200 export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
13201 if(!isWasmInitialized) {
13202 throw new Error("initializeWasm() must be awaited first!");
13204 const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
13205 // debug statements here
13207 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
13209 export function CVec_RouteHintZ_free(_res: number): void {
13210 if(!isWasmInitialized) {
13211 throw new Error("initializeWasm() must be awaited first!");
13213 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
13214 // debug statements here
13216 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
13218 export function CVec_RouteHintHopZ_free(_res: number): void {
13219 if(!isWasmInitialized) {
13220 throw new Error("initializeWasm() must be awaited first!");
13222 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
13223 // debug statements here
13225 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
13227 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
13228 if(!isWasmInitialized) {
13229 throw new Error("initializeWasm() must be awaited first!");
13231 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
13232 return nativeResponseValue;
13234 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
13236 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
13237 if(!isWasmInitialized) {
13238 throw new Error("initializeWasm() must be awaited first!");
13240 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
13241 return nativeResponseValue;
13243 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
13245 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
13246 if(!isWasmInitialized) {
13247 throw new Error("initializeWasm() must be awaited first!");
13249 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
13250 return nativeResponseValue;
13252 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
13254 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
13255 if(!isWasmInitialized) {
13256 throw new Error("initializeWasm() must be awaited first!");
13258 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
13259 // debug statements here
13261 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
13263 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13264 if(!isWasmInitialized) {
13265 throw new Error("initializeWasm() must be awaited first!");
13267 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
13268 return nativeResponseValue;
13270 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
13272 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
13273 if(!isWasmInitialized) {
13274 throw new Error("initializeWasm() must be awaited first!");
13276 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
13277 return nativeResponseValue;
13279 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
13281 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
13282 if(!isWasmInitialized) {
13283 throw new Error("initializeWasm() must be awaited first!");
13285 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
13286 return nativeResponseValue;
13288 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
13290 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
13291 if(!isWasmInitialized) {
13292 throw new Error("initializeWasm() must be awaited first!");
13294 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
13295 return nativeResponseValue;
13297 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
13299 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
13300 if(!isWasmInitialized) {
13301 throw new Error("initializeWasm() must be awaited first!");
13303 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
13304 return nativeResponseValue;
13306 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
13308 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
13309 if(!isWasmInitialized) {
13310 throw new Error("initializeWasm() must be awaited first!");
13312 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
13313 // debug statements here
13315 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
13317 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13318 if(!isWasmInitialized) {
13319 throw new Error("initializeWasm() must be awaited first!");
13321 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
13322 return nativeResponseValue;
13324 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
13326 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
13327 if(!isWasmInitialized) {
13328 throw new Error("initializeWasm() must be awaited first!");
13330 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
13331 return nativeResponseValue;
13333 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
13335 export function CVec_PublicKeyZ_free(_res: number): void {
13336 if(!isWasmInitialized) {
13337 throw new Error("initializeWasm() must be awaited first!");
13339 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
13340 // debug statements here
13342 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
13344 export function CVec_TransactionZ_free(_res: number): void {
13345 if(!isWasmInitialized) {
13346 throw new Error("initializeWasm() must be awaited first!");
13348 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
13349 // debug statements here
13351 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
13353 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
13354 if(!isWasmInitialized) {
13355 throw new Error("initializeWasm() must be awaited first!");
13357 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
13358 return nativeResponseValue;
13360 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
13362 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
13363 if(!isWasmInitialized) {
13364 throw new Error("initializeWasm() must be awaited first!");
13366 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
13367 return nativeResponseValue;
13369 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
13371 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
13372 if(!isWasmInitialized) {
13373 throw new Error("initializeWasm() must be awaited first!");
13375 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
13376 return nativeResponseValue;
13378 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
13380 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
13381 if(!isWasmInitialized) {
13382 throw new Error("initializeWasm() must be awaited first!");
13384 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
13385 // debug statements here
13387 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
13389 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
13390 if(!isWasmInitialized) {
13391 throw new Error("initializeWasm() must be awaited first!");
13393 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
13394 // debug statements here
13396 // struct LDKCOption_BlockHashZ COption_BlockHashZ_some(struct LDKThirtyTwoBytes o);
13398 export function COption_BlockHashZ_some(o: number): bigint {
13399 if(!isWasmInitialized) {
13400 throw new Error("initializeWasm() must be awaited first!");
13402 const nativeResponseValue = wasm.TS_COption_BlockHashZ_some(o);
13403 return nativeResponseValue;
13405 // struct LDKCOption_BlockHashZ COption_BlockHashZ_none(void);
13407 export function COption_BlockHashZ_none(): bigint {
13408 if(!isWasmInitialized) {
13409 throw new Error("initializeWasm() must be awaited first!");
13411 const nativeResponseValue = wasm.TS_COption_BlockHashZ_none();
13412 return nativeResponseValue;
13414 // void COption_BlockHashZ_free(struct LDKCOption_BlockHashZ _res);
13416 export function COption_BlockHashZ_free(_res: bigint): void {
13417 if(!isWasmInitialized) {
13418 throw new Error("initializeWasm() must be awaited first!");
13420 const nativeResponseValue = wasm.TS_COption_BlockHashZ_free(_res);
13421 // debug statements here
13423 // uint64_t COption_BlockHashZ_clone_ptr(LDKCOption_BlockHashZ *NONNULL_PTR arg);
13425 export function COption_BlockHashZ_clone_ptr(arg: bigint): bigint {
13426 if(!isWasmInitialized) {
13427 throw new Error("initializeWasm() must be awaited first!");
13429 const nativeResponseValue = wasm.TS_COption_BlockHashZ_clone_ptr(arg);
13430 return nativeResponseValue;
13432 // struct LDKCOption_BlockHashZ COption_BlockHashZ_clone(const struct LDKCOption_BlockHashZ *NONNULL_PTR orig);
13434 export function COption_BlockHashZ_clone(orig: bigint): bigint {
13435 if(!isWasmInitialized) {
13436 throw new Error("initializeWasm() must be awaited first!");
13438 const nativeResponseValue = wasm.TS_COption_BlockHashZ_clone(orig);
13439 return nativeResponseValue;
13441 // uint64_t C2Tuple_TxidCOption_BlockHashZZ_clone_ptr(LDKC2Tuple_TxidCOption_BlockHashZZ *NONNULL_PTR arg);
13443 export function C2Tuple_TxidCOption_BlockHashZZ_clone_ptr(arg: bigint): bigint {
13444 if(!isWasmInitialized) {
13445 throw new Error("initializeWasm() must be awaited first!");
13447 const nativeResponseValue = wasm.TS_C2Tuple_TxidCOption_BlockHashZZ_clone_ptr(arg);
13448 return nativeResponseValue;
13450 // struct LDKC2Tuple_TxidCOption_BlockHashZZ C2Tuple_TxidCOption_BlockHashZZ_clone(const struct LDKC2Tuple_TxidCOption_BlockHashZZ *NONNULL_PTR orig);
13452 export function C2Tuple_TxidCOption_BlockHashZZ_clone(orig: bigint): bigint {
13453 if(!isWasmInitialized) {
13454 throw new Error("initializeWasm() must be awaited first!");
13456 const nativeResponseValue = wasm.TS_C2Tuple_TxidCOption_BlockHashZZ_clone(orig);
13457 return nativeResponseValue;
13459 // struct LDKC2Tuple_TxidCOption_BlockHashZZ C2Tuple_TxidCOption_BlockHashZZ_new(struct LDKThirtyTwoBytes a, struct LDKCOption_BlockHashZ b);
13461 export function C2Tuple_TxidCOption_BlockHashZZ_new(a: number, b: bigint): bigint {
13462 if(!isWasmInitialized) {
13463 throw new Error("initializeWasm() must be awaited first!");
13465 const nativeResponseValue = wasm.TS_C2Tuple_TxidCOption_BlockHashZZ_new(a, b);
13466 return nativeResponseValue;
13468 // void C2Tuple_TxidCOption_BlockHashZZ_free(struct LDKC2Tuple_TxidCOption_BlockHashZZ _res);
13470 export function C2Tuple_TxidCOption_BlockHashZZ_free(_res: bigint): void {
13471 if(!isWasmInitialized) {
13472 throw new Error("initializeWasm() must be awaited first!");
13474 const nativeResponseValue = wasm.TS_C2Tuple_TxidCOption_BlockHashZZ_free(_res);
13475 // debug statements here
13477 // void CVec_C2Tuple_TxidCOption_BlockHashZZZ_free(struct LDKCVec_C2Tuple_TxidCOption_BlockHashZZZ _res);
13479 export function CVec_C2Tuple_TxidCOption_BlockHashZZZ_free(_res: number): void {
13480 if(!isWasmInitialized) {
13481 throw new Error("initializeWasm() must be awaited first!");
13483 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCOption_BlockHashZZZ_free(_res);
13484 // debug statements here
13486 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
13488 export function CVec_MonitorEventZ_free(_res: number): void {
13489 if(!isWasmInitialized) {
13490 throw new Error("initializeWasm() must be awaited first!");
13492 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
13493 // debug statements here
13495 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
13497 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
13498 if(!isWasmInitialized) {
13499 throw new Error("initializeWasm() must be awaited first!");
13501 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
13502 return nativeResponseValue;
13504 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
13506 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
13507 if(!isWasmInitialized) {
13508 throw new Error("initializeWasm() must be awaited first!");
13510 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
13511 return nativeResponseValue;
13513 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
13515 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
13516 if(!isWasmInitialized) {
13517 throw new Error("initializeWasm() must be awaited first!");
13519 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
13520 return nativeResponseValue;
13522 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
13524 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
13525 if(!isWasmInitialized) {
13526 throw new Error("initializeWasm() must be awaited first!");
13528 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
13529 // debug statements here
13531 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
13533 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
13534 if(!isWasmInitialized) {
13535 throw new Error("initializeWasm() must be awaited first!");
13537 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
13538 // debug statements here
13540 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
13542 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
13543 if(!isWasmInitialized) {
13544 throw new Error("initializeWasm() must be awaited first!");
13546 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
13547 return nativeResponseValue;
13549 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
13551 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
13552 if(!isWasmInitialized) {
13553 throw new Error("initializeWasm() must be awaited first!");
13555 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
13556 return nativeResponseValue;
13558 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
13560 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
13561 if(!isWasmInitialized) {
13562 throw new Error("initializeWasm() must be awaited first!");
13564 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
13565 return nativeResponseValue;
13567 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
13569 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
13570 if(!isWasmInitialized) {
13571 throw new Error("initializeWasm() must be awaited first!");
13573 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
13574 // debug statements here
13576 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
13578 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13579 if(!isWasmInitialized) {
13580 throw new Error("initializeWasm() must be awaited first!");
13582 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
13583 return nativeResponseValue;
13585 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
13587 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
13588 if(!isWasmInitialized) {
13589 throw new Error("initializeWasm() must be awaited first!");
13591 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
13592 return nativeResponseValue;
13594 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
13596 export function CVec_NodeIdZ_free(_res: number): void {
13597 if(!isWasmInitialized) {
13598 throw new Error("initializeWasm() must be awaited first!");
13600 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
13601 // debug statements here
13603 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
13605 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
13606 if(!isWasmInitialized) {
13607 throw new Error("initializeWasm() must be awaited first!");
13609 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
13610 return nativeResponseValue;
13612 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
13614 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
13615 if(!isWasmInitialized) {
13616 throw new Error("initializeWasm() must be awaited first!");
13618 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
13619 return nativeResponseValue;
13621 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
13623 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
13624 if(!isWasmInitialized) {
13625 throw new Error("initializeWasm() must be awaited first!");
13627 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
13628 return nativeResponseValue;
13630 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
13632 export function C2Tuple_u64u64Z_free(_res: bigint): void {
13633 if(!isWasmInitialized) {
13634 throw new Error("initializeWasm() must be awaited first!");
13636 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
13637 // debug statements here
13639 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
13641 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
13642 if(!isWasmInitialized) {
13643 throw new Error("initializeWasm() must be awaited first!");
13645 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
13646 return nativeResponseValue;
13648 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
13650 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
13651 if(!isWasmInitialized) {
13652 throw new Error("initializeWasm() must be awaited first!");
13654 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
13655 return nativeResponseValue;
13657 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
13659 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
13660 if(!isWasmInitialized) {
13661 throw new Error("initializeWasm() must be awaited first!");
13663 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
13664 // debug statements here
13666 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
13668 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
13669 if(!isWasmInitialized) {
13670 throw new Error("initializeWasm() must be awaited first!");
13672 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
13673 return nativeResponseValue;
13675 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
13677 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
13678 if(!isWasmInitialized) {
13679 throw new Error("initializeWasm() must be awaited first!");
13681 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
13682 return nativeResponseValue;
13684 // uint64_t C2Tuple_Z_clone_ptr(LDKC2Tuple_Z *NONNULL_PTR arg);
13686 export function C2Tuple_Z_clone_ptr(arg: bigint): bigint {
13687 if(!isWasmInitialized) {
13688 throw new Error("initializeWasm() must be awaited first!");
13690 const nativeResponseValue = wasm.TS_C2Tuple_Z_clone_ptr(arg);
13691 return nativeResponseValue;
13693 // struct LDKC2Tuple_Z C2Tuple_Z_clone(const struct LDKC2Tuple_Z *NONNULL_PTR orig);
13695 export function C2Tuple_Z_clone(orig: bigint): bigint {
13696 if(!isWasmInitialized) {
13697 throw new Error("initializeWasm() must be awaited first!");
13699 const nativeResponseValue = wasm.TS_C2Tuple_Z_clone(orig);
13700 return nativeResponseValue;
13702 // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
13704 export function C2Tuple_Z_new(a: number, b: number): bigint {
13705 if(!isWasmInitialized) {
13706 throw new Error("initializeWasm() must be awaited first!");
13708 const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
13709 return nativeResponseValue;
13711 // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
13713 export function C2Tuple_Z_free(_res: bigint): void {
13714 if(!isWasmInitialized) {
13715 throw new Error("initializeWasm() must be awaited first!");
13717 const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
13718 // debug statements here
13720 // uint64_t C2Tuple__u168_u168Z_clone_ptr(LDKC2Tuple__u168_u168Z *NONNULL_PTR arg);
13722 export function C2Tuple__u168_u168Z_clone_ptr(arg: bigint): bigint {
13723 if(!isWasmInitialized) {
13724 throw new Error("initializeWasm() must be awaited first!");
13726 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone_ptr(arg);
13727 return nativeResponseValue;
13729 // struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_clone(const struct LDKC2Tuple__u168_u168Z *NONNULL_PTR orig);
13731 export function C2Tuple__u168_u168Z_clone(orig: bigint): bigint {
13732 if(!isWasmInitialized) {
13733 throw new Error("initializeWasm() must be awaited first!");
13735 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_clone(orig);
13736 return nativeResponseValue;
13738 // struct LDKC2Tuple__u168_u168Z C2Tuple__u168_u168Z_new(struct LDKEightU16s a, struct LDKEightU16s b);
13740 export function C2Tuple__u168_u168Z_new(a: number, b: number): bigint {
13741 if(!isWasmInitialized) {
13742 throw new Error("initializeWasm() must be awaited first!");
13744 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_new(a, b);
13745 return nativeResponseValue;
13747 // void C2Tuple__u168_u168Z_free(struct LDKC2Tuple__u168_u168Z _res);
13749 export function C2Tuple__u168_u168Z_free(_res: bigint): void {
13750 if(!isWasmInitialized) {
13751 throw new Error("initializeWasm() must be awaited first!");
13753 const nativeResponseValue = wasm.TS_C2Tuple__u168_u168Z_free(_res);
13754 // debug statements here
13756 // struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_some(struct LDKC2Tuple__u168_u168Z o);
13758 export function COption_C2Tuple_EightU16sEightU16sZZ_some(o: bigint): bigint {
13759 if(!isWasmInitialized) {
13760 throw new Error("initializeWasm() must be awaited first!");
13762 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_some(o);
13763 return nativeResponseValue;
13765 // struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_none(void);
13767 export function COption_C2Tuple_EightU16sEightU16sZZ_none(): bigint {
13768 if(!isWasmInitialized) {
13769 throw new Error("initializeWasm() must be awaited first!");
13771 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_none();
13772 return nativeResponseValue;
13774 // void COption_C2Tuple_EightU16sEightU16sZZ_free(struct LDKCOption_C2Tuple_EightU16sEightU16sZZ _res);
13776 export function COption_C2Tuple_EightU16sEightU16sZZ_free(_res: bigint): void {
13777 if(!isWasmInitialized) {
13778 throw new Error("initializeWasm() must be awaited first!");
13780 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_free(_res);
13781 // debug statements here
13783 // uint64_t COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR arg);
13785 export function COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg: bigint): bigint {
13786 if(!isWasmInitialized) {
13787 throw new Error("initializeWasm() must be awaited first!");
13789 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg);
13790 return nativeResponseValue;
13792 // struct LDKCOption_C2Tuple_EightU16sEightU16sZZ COption_C2Tuple_EightU16sEightU16sZZ_clone(const struct LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR orig);
13794 export function COption_C2Tuple_EightU16sEightU16sZZ_clone(orig: bigint): bigint {
13795 if(!isWasmInitialized) {
13796 throw new Error("initializeWasm() must be awaited first!");
13798 const nativeResponseValue = wasm.TS_COption_C2Tuple_EightU16sEightU16sZZ_clone(orig);
13799 return nativeResponseValue;
13801 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
13803 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
13804 if(!isWasmInitialized) {
13805 throw new Error("initializeWasm() must be awaited first!");
13807 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
13808 return nativeResponseValue;
13810 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
13812 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
13813 if(!isWasmInitialized) {
13814 throw new Error("initializeWasm() must be awaited first!");
13816 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
13817 return nativeResponseValue;
13819 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
13821 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
13822 if(!isWasmInitialized) {
13823 throw new Error("initializeWasm() must be awaited first!");
13825 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
13826 return nativeResponseValue;
13828 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
13830 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
13831 if(!isWasmInitialized) {
13832 throw new Error("initializeWasm() must be awaited first!");
13834 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
13835 // debug statements here
13837 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
13839 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13840 if(!isWasmInitialized) {
13841 throw new Error("initializeWasm() must be awaited first!");
13843 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
13844 return nativeResponseValue;
13846 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13848 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
13849 if(!isWasmInitialized) {
13850 throw new Error("initializeWasm() must be awaited first!");
13852 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
13853 return nativeResponseValue;
13855 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
13857 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13858 if(!isWasmInitialized) {
13859 throw new Error("initializeWasm() must be awaited first!");
13861 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
13862 return nativeResponseValue;
13864 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
13866 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
13867 if(!isWasmInitialized) {
13868 throw new Error("initializeWasm() must be awaited first!");
13870 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
13871 // debug statements here
13873 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
13875 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13876 if(!isWasmInitialized) {
13877 throw new Error("initializeWasm() must be awaited first!");
13879 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
13880 return nativeResponseValue;
13882 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
13884 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13885 if(!isWasmInitialized) {
13886 throw new Error("initializeWasm() must be awaited first!");
13888 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
13889 return nativeResponseValue;
13891 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
13893 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13894 if(!isWasmInitialized) {
13895 throw new Error("initializeWasm() must be awaited first!");
13897 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
13898 return nativeResponseValue;
13900 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13902 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
13903 if(!isWasmInitialized) {
13904 throw new Error("initializeWasm() must be awaited first!");
13906 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
13907 return nativeResponseValue;
13909 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
13911 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13912 if(!isWasmInitialized) {
13913 throw new Error("initializeWasm() must be awaited first!");
13915 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
13916 return nativeResponseValue;
13918 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
13920 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
13921 if(!isWasmInitialized) {
13922 throw new Error("initializeWasm() must be awaited first!");
13924 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
13925 // debug statements here
13927 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
13929 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13930 if(!isWasmInitialized) {
13931 throw new Error("initializeWasm() must be awaited first!");
13933 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
13934 return nativeResponseValue;
13936 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
13938 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13939 if(!isWasmInitialized) {
13940 throw new Error("initializeWasm() must be awaited first!");
13942 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
13943 return nativeResponseValue;
13945 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
13947 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13948 if(!isWasmInitialized) {
13949 throw new Error("initializeWasm() must be awaited first!");
13951 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
13952 return nativeResponseValue;
13954 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13956 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
13957 if(!isWasmInitialized) {
13958 throw new Error("initializeWasm() must be awaited first!");
13960 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
13961 return nativeResponseValue;
13963 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
13965 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13966 if(!isWasmInitialized) {
13967 throw new Error("initializeWasm() must be awaited first!");
13969 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
13970 return nativeResponseValue;
13972 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
13974 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
13975 if(!isWasmInitialized) {
13976 throw new Error("initializeWasm() must be awaited first!");
13978 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
13979 // debug statements here
13981 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
13983 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13984 if(!isWasmInitialized) {
13985 throw new Error("initializeWasm() must be awaited first!");
13987 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
13988 return nativeResponseValue;
13990 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
13992 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13993 if(!isWasmInitialized) {
13994 throw new Error("initializeWasm() must be awaited first!");
13996 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
13997 return nativeResponseValue;
13999 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt11InvoiceFeatures o);
14001 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14002 if(!isWasmInitialized) {
14003 throw new Error("initializeWasm() must be awaited first!");
14005 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o);
14006 return nativeResponseValue;
14008 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14010 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
14011 if(!isWasmInitialized) {
14012 throw new Error("initializeWasm() must be awaited first!");
14014 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e);
14015 return nativeResponseValue;
14017 // bool CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
14019 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14020 if(!isWasmInitialized) {
14021 throw new Error("initializeWasm() must be awaited first!");
14023 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o);
14024 return nativeResponseValue;
14026 // void CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res);
14028 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
14029 if(!isWasmInitialized) {
14030 throw new Error("initializeWasm() must be awaited first!");
14032 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res);
14033 // debug statements here
14035 // uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
14037 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14038 if(!isWasmInitialized) {
14039 throw new Error("initializeWasm() must be awaited first!");
14041 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
14042 return nativeResponseValue;
14044 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
14046 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14047 if(!isWasmInitialized) {
14048 throw new Error("initializeWasm() must be awaited first!");
14050 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig);
14051 return nativeResponseValue;
14053 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt12InvoiceFeatures o);
14055 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14056 if(!isWasmInitialized) {
14057 throw new Error("initializeWasm() must be awaited first!");
14059 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o);
14060 return nativeResponseValue;
14062 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14064 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
14065 if(!isWasmInitialized) {
14066 throw new Error("initializeWasm() must be awaited first!");
14068 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e);
14069 return nativeResponseValue;
14071 // bool CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
14073 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14074 if(!isWasmInitialized) {
14075 throw new Error("initializeWasm() must be awaited first!");
14077 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o);
14078 return nativeResponseValue;
14080 // void CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res);
14082 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
14083 if(!isWasmInitialized) {
14084 throw new Error("initializeWasm() must be awaited first!");
14086 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res);
14087 // debug statements here
14089 // uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
14091 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14092 if(!isWasmInitialized) {
14093 throw new Error("initializeWasm() must be awaited first!");
14095 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
14096 return nativeResponseValue;
14098 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
14100 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14101 if(!isWasmInitialized) {
14102 throw new Error("initializeWasm() must be awaited first!");
14104 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig);
14105 return nativeResponseValue;
14107 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
14109 export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14110 if(!isWasmInitialized) {
14111 throw new Error("initializeWasm() must be awaited first!");
14113 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
14114 return nativeResponseValue;
14116 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14118 export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
14119 if(!isWasmInitialized) {
14120 throw new Error("initializeWasm() must be awaited first!");
14122 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
14123 return nativeResponseValue;
14125 // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
14127 export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14128 if(!isWasmInitialized) {
14129 throw new Error("initializeWasm() must be awaited first!");
14131 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
14132 return nativeResponseValue;
14134 // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
14136 export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
14137 if(!isWasmInitialized) {
14138 throw new Error("initializeWasm() must be awaited first!");
14140 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
14141 // debug statements here
14143 // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
14145 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14146 if(!isWasmInitialized) {
14147 throw new Error("initializeWasm() must be awaited first!");
14149 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
14150 return nativeResponseValue;
14152 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
14154 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14155 if(!isWasmInitialized) {
14156 throw new Error("initializeWasm() must be awaited first!");
14158 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
14159 return nativeResponseValue;
14161 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
14163 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14164 if(!isWasmInitialized) {
14165 throw new Error("initializeWasm() must be awaited first!");
14167 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
14168 return nativeResponseValue;
14170 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14172 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
14173 if(!isWasmInitialized) {
14174 throw new Error("initializeWasm() must be awaited first!");
14176 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
14177 return nativeResponseValue;
14179 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
14181 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14182 if(!isWasmInitialized) {
14183 throw new Error("initializeWasm() must be awaited first!");
14185 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
14186 return nativeResponseValue;
14188 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
14190 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
14191 if(!isWasmInitialized) {
14192 throw new Error("initializeWasm() must be awaited first!");
14194 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
14195 // debug statements here
14197 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
14199 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14200 if(!isWasmInitialized) {
14201 throw new Error("initializeWasm() must be awaited first!");
14203 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
14204 return nativeResponseValue;
14206 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
14208 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14209 if(!isWasmInitialized) {
14210 throw new Error("initializeWasm() must be awaited first!");
14212 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
14213 return nativeResponseValue;
14215 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
14217 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
14218 if(!isWasmInitialized) {
14219 throw new Error("initializeWasm() must be awaited first!");
14221 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
14222 return nativeResponseValue;
14224 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
14226 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
14227 if(!isWasmInitialized) {
14228 throw new Error("initializeWasm() must be awaited first!");
14230 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
14231 return nativeResponseValue;
14233 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
14235 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
14236 if(!isWasmInitialized) {
14237 throw new Error("initializeWasm() must be awaited first!");
14239 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
14240 return nativeResponseValue;
14242 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
14244 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
14245 if(!isWasmInitialized) {
14246 throw new Error("initializeWasm() must be awaited first!");
14248 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
14249 // debug statements here
14251 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
14253 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14254 if(!isWasmInitialized) {
14255 throw new Error("initializeWasm() must be awaited first!");
14257 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
14258 return nativeResponseValue;
14260 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
14262 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
14263 if(!isWasmInitialized) {
14264 throw new Error("initializeWasm() must be awaited first!");
14266 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
14267 return nativeResponseValue;
14269 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
14271 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
14272 if(!isWasmInitialized) {
14273 throw new Error("initializeWasm() must be awaited first!");
14275 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
14276 return nativeResponseValue;
14278 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
14280 export function COption_NetworkUpdateZ_none(): bigint {
14281 if(!isWasmInitialized) {
14282 throw new Error("initializeWasm() must be awaited first!");
14284 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
14285 return nativeResponseValue;
14287 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
14289 export function COption_NetworkUpdateZ_free(_res: bigint): void {
14290 if(!isWasmInitialized) {
14291 throw new Error("initializeWasm() must be awaited first!");
14293 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
14294 // debug statements here
14296 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
14298 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
14299 if(!isWasmInitialized) {
14300 throw new Error("initializeWasm() must be awaited first!");
14302 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
14303 return nativeResponseValue;
14305 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
14307 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
14308 if(!isWasmInitialized) {
14309 throw new Error("initializeWasm() must be awaited first!");
14311 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
14312 return nativeResponseValue;
14314 // struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
14316 export function COption_PathFailureZ_some(o: bigint): bigint {
14317 if(!isWasmInitialized) {
14318 throw new Error("initializeWasm() must be awaited first!");
14320 const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
14321 return nativeResponseValue;
14323 // struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
14325 export function COption_PathFailureZ_none(): bigint {
14326 if(!isWasmInitialized) {
14327 throw new Error("initializeWasm() must be awaited first!");
14329 const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
14330 return nativeResponseValue;
14332 // void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
14334 export function COption_PathFailureZ_free(_res: bigint): void {
14335 if(!isWasmInitialized) {
14336 throw new Error("initializeWasm() must be awaited first!");
14338 const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
14339 // debug statements here
14341 // uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
14343 export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
14344 if(!isWasmInitialized) {
14345 throw new Error("initializeWasm() must be awaited first!");
14347 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
14348 return nativeResponseValue;
14350 // struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
14352 export function COption_PathFailureZ_clone(orig: bigint): bigint {
14353 if(!isWasmInitialized) {
14354 throw new Error("initializeWasm() must be awaited first!");
14356 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
14357 return nativeResponseValue;
14359 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
14361 export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
14362 if(!isWasmInitialized) {
14363 throw new Error("initializeWasm() must be awaited first!");
14365 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
14366 return nativeResponseValue;
14368 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
14370 export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
14371 if(!isWasmInitialized) {
14372 throw new Error("initializeWasm() must be awaited first!");
14374 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
14375 return nativeResponseValue;
14377 // bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
14379 export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
14380 if(!isWasmInitialized) {
14381 throw new Error("initializeWasm() must be awaited first!");
14383 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
14384 return nativeResponseValue;
14386 // void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
14388 export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
14389 if(!isWasmInitialized) {
14390 throw new Error("initializeWasm() must be awaited first!");
14392 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
14393 // debug statements here
14395 // uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
14397 export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14398 if(!isWasmInitialized) {
14399 throw new Error("initializeWasm() must be awaited first!");
14401 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
14402 return nativeResponseValue;
14404 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
14406 export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
14407 if(!isWasmInitialized) {
14408 throw new Error("initializeWasm() must be awaited first!");
14410 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
14411 return nativeResponseValue;
14413 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
14415 export function COption_ClosureReasonZ_some(o: bigint): bigint {
14416 if(!isWasmInitialized) {
14417 throw new Error("initializeWasm() must be awaited first!");
14419 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
14420 return nativeResponseValue;
14422 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
14424 export function COption_ClosureReasonZ_none(): bigint {
14425 if(!isWasmInitialized) {
14426 throw new Error("initializeWasm() must be awaited first!");
14428 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
14429 return nativeResponseValue;
14431 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
14433 export function COption_ClosureReasonZ_free(_res: bigint): void {
14434 if(!isWasmInitialized) {
14435 throw new Error("initializeWasm() must be awaited first!");
14437 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
14438 // debug statements here
14440 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
14442 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
14443 if(!isWasmInitialized) {
14444 throw new Error("initializeWasm() must be awaited first!");
14446 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
14447 return nativeResponseValue;
14449 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
14451 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
14452 if(!isWasmInitialized) {
14453 throw new Error("initializeWasm() must be awaited first!");
14455 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
14456 return nativeResponseValue;
14458 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
14460 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
14461 if(!isWasmInitialized) {
14462 throw new Error("initializeWasm() must be awaited first!");
14464 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
14465 return nativeResponseValue;
14467 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
14469 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
14470 if(!isWasmInitialized) {
14471 throw new Error("initializeWasm() must be awaited first!");
14473 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
14474 return nativeResponseValue;
14476 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
14478 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
14479 if(!isWasmInitialized) {
14480 throw new Error("initializeWasm() must be awaited first!");
14482 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
14483 return nativeResponseValue;
14485 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
14487 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
14488 if(!isWasmInitialized) {
14489 throw new Error("initializeWasm() must be awaited first!");
14491 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
14492 // debug statements here
14494 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
14496 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14497 if(!isWasmInitialized) {
14498 throw new Error("initializeWasm() must be awaited first!");
14500 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
14501 return nativeResponseValue;
14503 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
14505 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
14506 if(!isWasmInitialized) {
14507 throw new Error("initializeWasm() must be awaited first!");
14509 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
14510 return nativeResponseValue;
14512 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
14514 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
14515 if(!isWasmInitialized) {
14516 throw new Error("initializeWasm() must be awaited first!");
14518 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
14519 return nativeResponseValue;
14521 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
14523 export function COption_HTLCDestinationZ_none(): bigint {
14524 if(!isWasmInitialized) {
14525 throw new Error("initializeWasm() must be awaited first!");
14527 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
14528 return nativeResponseValue;
14530 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
14532 export function COption_HTLCDestinationZ_free(_res: bigint): void {
14533 if(!isWasmInitialized) {
14534 throw new Error("initializeWasm() must be awaited first!");
14536 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
14537 // debug statements here
14539 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
14541 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
14542 if(!isWasmInitialized) {
14543 throw new Error("initializeWasm() must be awaited first!");
14545 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
14546 return nativeResponseValue;
14548 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
14550 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
14551 if(!isWasmInitialized) {
14552 throw new Error("initializeWasm() must be awaited first!");
14554 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
14555 return nativeResponseValue;
14557 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
14559 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
14560 if(!isWasmInitialized) {
14561 throw new Error("initializeWasm() must be awaited first!");
14563 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
14564 return nativeResponseValue;
14566 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
14568 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
14569 if(!isWasmInitialized) {
14570 throw new Error("initializeWasm() must be awaited first!");
14572 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
14573 return nativeResponseValue;
14575 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
14577 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
14578 if(!isWasmInitialized) {
14579 throw new Error("initializeWasm() must be awaited first!");
14581 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
14582 return nativeResponseValue;
14584 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
14586 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
14587 if(!isWasmInitialized) {
14588 throw new Error("initializeWasm() must be awaited first!");
14590 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
14591 // debug statements here
14593 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
14595 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14596 if(!isWasmInitialized) {
14597 throw new Error("initializeWasm() must be awaited first!");
14599 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
14600 return nativeResponseValue;
14602 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
14604 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
14605 if(!isWasmInitialized) {
14606 throw new Error("initializeWasm() must be awaited first!");
14608 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
14609 return nativeResponseValue;
14611 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_ok(enum LDKPaymentFailureReason o);
14613 export function CResult_PaymentFailureReasonDecodeErrorZ_ok(o: PaymentFailureReason): bigint {
14614 if(!isWasmInitialized) {
14615 throw new Error("initializeWasm() must be awaited first!");
14617 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(o);
14618 return nativeResponseValue;
14620 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_err(struct LDKDecodeError e);
14622 export function CResult_PaymentFailureReasonDecodeErrorZ_err(e: bigint): bigint {
14623 if(!isWasmInitialized) {
14624 throw new Error("initializeWasm() must be awaited first!");
14626 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_err(e);
14627 return nativeResponseValue;
14629 // bool CResult_PaymentFailureReasonDecodeErrorZ_is_ok(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR o);
14631 export function CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o: bigint): boolean {
14632 if(!isWasmInitialized) {
14633 throw new Error("initializeWasm() must be awaited first!");
14635 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o);
14636 return nativeResponseValue;
14638 // void CResult_PaymentFailureReasonDecodeErrorZ_free(struct LDKCResult_PaymentFailureReasonDecodeErrorZ _res);
14640 export function CResult_PaymentFailureReasonDecodeErrorZ_free(_res: bigint): void {
14641 if(!isWasmInitialized) {
14642 throw new Error("initializeWasm() must be awaited first!");
14644 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_free(_res);
14645 // debug statements here
14647 // uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg);
14649 export function CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14650 if(!isWasmInitialized) {
14651 throw new Error("initializeWasm() must be awaited first!");
14653 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg);
14654 return nativeResponseValue;
14656 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_clone(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR orig);
14658 export function CResult_PaymentFailureReasonDecodeErrorZ_clone(orig: bigint): bigint {
14659 if(!isWasmInitialized) {
14660 throw new Error("initializeWasm() must be awaited first!");
14662 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(orig);
14663 return nativeResponseValue;
14665 // struct LDKCOption_u128Z COption_u128Z_some(struct LDKU128 o);
14667 export function COption_u128Z_some(o: number): bigint {
14668 if(!isWasmInitialized) {
14669 throw new Error("initializeWasm() must be awaited first!");
14671 const nativeResponseValue = wasm.TS_COption_u128Z_some(o);
14672 return nativeResponseValue;
14674 // struct LDKCOption_u128Z COption_u128Z_none(void);
14676 export function COption_u128Z_none(): bigint {
14677 if(!isWasmInitialized) {
14678 throw new Error("initializeWasm() must be awaited first!");
14680 const nativeResponseValue = wasm.TS_COption_u128Z_none();
14681 return nativeResponseValue;
14683 // void COption_u128Z_free(struct LDKCOption_u128Z _res);
14685 export function COption_u128Z_free(_res: bigint): void {
14686 if(!isWasmInitialized) {
14687 throw new Error("initializeWasm() must be awaited first!");
14689 const nativeResponseValue = wasm.TS_COption_u128Z_free(_res);
14690 // debug statements here
14692 // uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg);
14694 export function COption_u128Z_clone_ptr(arg: bigint): bigint {
14695 if(!isWasmInitialized) {
14696 throw new Error("initializeWasm() must be awaited first!");
14698 const nativeResponseValue = wasm.TS_COption_u128Z_clone_ptr(arg);
14699 return nativeResponseValue;
14701 // struct LDKCOption_u128Z COption_u128Z_clone(const struct LDKCOption_u128Z *NONNULL_PTR orig);
14703 export function COption_u128Z_clone(orig: bigint): bigint {
14704 if(!isWasmInitialized) {
14705 throw new Error("initializeWasm() must be awaited first!");
14707 const nativeResponseValue = wasm.TS_COption_u128Z_clone(orig);
14708 return nativeResponseValue;
14710 // struct LDKCOption_PaymentIdZ COption_PaymentIdZ_some(struct LDKThirtyTwoBytes o);
14712 export function COption_PaymentIdZ_some(o: number): bigint {
14713 if(!isWasmInitialized) {
14714 throw new Error("initializeWasm() must be awaited first!");
14716 const nativeResponseValue = wasm.TS_COption_PaymentIdZ_some(o);
14717 return nativeResponseValue;
14719 // struct LDKCOption_PaymentIdZ COption_PaymentIdZ_none(void);
14721 export function COption_PaymentIdZ_none(): bigint {
14722 if(!isWasmInitialized) {
14723 throw new Error("initializeWasm() must be awaited first!");
14725 const nativeResponseValue = wasm.TS_COption_PaymentIdZ_none();
14726 return nativeResponseValue;
14728 // void COption_PaymentIdZ_free(struct LDKCOption_PaymentIdZ _res);
14730 export function COption_PaymentIdZ_free(_res: bigint): void {
14731 if(!isWasmInitialized) {
14732 throw new Error("initializeWasm() must be awaited first!");
14734 const nativeResponseValue = wasm.TS_COption_PaymentIdZ_free(_res);
14735 // debug statements here
14737 // uint64_t COption_PaymentIdZ_clone_ptr(LDKCOption_PaymentIdZ *NONNULL_PTR arg);
14739 export function COption_PaymentIdZ_clone_ptr(arg: bigint): bigint {
14740 if(!isWasmInitialized) {
14741 throw new Error("initializeWasm() must be awaited first!");
14743 const nativeResponseValue = wasm.TS_COption_PaymentIdZ_clone_ptr(arg);
14744 return nativeResponseValue;
14746 // struct LDKCOption_PaymentIdZ COption_PaymentIdZ_clone(const struct LDKCOption_PaymentIdZ *NONNULL_PTR orig);
14748 export function COption_PaymentIdZ_clone(orig: bigint): bigint {
14749 if(!isWasmInitialized) {
14750 throw new Error("initializeWasm() must be awaited first!");
14752 const nativeResponseValue = wasm.TS_COption_PaymentIdZ_clone(orig);
14753 return nativeResponseValue;
14755 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_some(enum LDKPaymentFailureReason o);
14757 export function COption_PaymentFailureReasonZ_some(o: PaymentFailureReason): bigint {
14758 if(!isWasmInitialized) {
14759 throw new Error("initializeWasm() must be awaited first!");
14761 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_some(o);
14762 return nativeResponseValue;
14764 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_none(void);
14766 export function COption_PaymentFailureReasonZ_none(): bigint {
14767 if(!isWasmInitialized) {
14768 throw new Error("initializeWasm() must be awaited first!");
14770 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_none();
14771 return nativeResponseValue;
14773 // void COption_PaymentFailureReasonZ_free(struct LDKCOption_PaymentFailureReasonZ _res);
14775 export function COption_PaymentFailureReasonZ_free(_res: bigint): void {
14776 if(!isWasmInitialized) {
14777 throw new Error("initializeWasm() must be awaited first!");
14779 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_free(_res);
14780 // debug statements here
14782 // uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg);
14784 export function COption_PaymentFailureReasonZ_clone_ptr(arg: bigint): bigint {
14785 if(!isWasmInitialized) {
14786 throw new Error("initializeWasm() must be awaited first!");
14788 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone_ptr(arg);
14789 return nativeResponseValue;
14791 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_clone(const struct LDKCOption_PaymentFailureReasonZ *NONNULL_PTR orig);
14793 export function COption_PaymentFailureReasonZ_clone(orig: bigint): bigint {
14794 if(!isWasmInitialized) {
14795 throw new Error("initializeWasm() must be awaited first!");
14797 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone(orig);
14798 return nativeResponseValue;
14800 // struct LDKCOption_PaymentHashZ COption_PaymentHashZ_some(struct LDKThirtyTwoBytes o);
14802 export function COption_PaymentHashZ_some(o: number): bigint {
14803 if(!isWasmInitialized) {
14804 throw new Error("initializeWasm() must be awaited first!");
14806 const nativeResponseValue = wasm.TS_COption_PaymentHashZ_some(o);
14807 return nativeResponseValue;
14809 // struct LDKCOption_PaymentHashZ COption_PaymentHashZ_none(void);
14811 export function COption_PaymentHashZ_none(): bigint {
14812 if(!isWasmInitialized) {
14813 throw new Error("initializeWasm() must be awaited first!");
14815 const nativeResponseValue = wasm.TS_COption_PaymentHashZ_none();
14816 return nativeResponseValue;
14818 // void COption_PaymentHashZ_free(struct LDKCOption_PaymentHashZ _res);
14820 export function COption_PaymentHashZ_free(_res: bigint): void {
14821 if(!isWasmInitialized) {
14822 throw new Error("initializeWasm() must be awaited first!");
14824 const nativeResponseValue = wasm.TS_COption_PaymentHashZ_free(_res);
14825 // debug statements here
14827 // uint64_t COption_PaymentHashZ_clone_ptr(LDKCOption_PaymentHashZ *NONNULL_PTR arg);
14829 export function COption_PaymentHashZ_clone_ptr(arg: bigint): bigint {
14830 if(!isWasmInitialized) {
14831 throw new Error("initializeWasm() must be awaited first!");
14833 const nativeResponseValue = wasm.TS_COption_PaymentHashZ_clone_ptr(arg);
14834 return nativeResponseValue;
14836 // struct LDKCOption_PaymentHashZ COption_PaymentHashZ_clone(const struct LDKCOption_PaymentHashZ *NONNULL_PTR orig);
14838 export function COption_PaymentHashZ_clone(orig: bigint): bigint {
14839 if(!isWasmInitialized) {
14840 throw new Error("initializeWasm() must be awaited first!");
14842 const nativeResponseValue = wasm.TS_COption_PaymentHashZ_clone(orig);
14843 return nativeResponseValue;
14845 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
14847 export function COption_EventZ_some(o: bigint): bigint {
14848 if(!isWasmInitialized) {
14849 throw new Error("initializeWasm() must be awaited first!");
14851 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
14852 return nativeResponseValue;
14854 // struct LDKCOption_EventZ COption_EventZ_none(void);
14856 export function COption_EventZ_none(): bigint {
14857 if(!isWasmInitialized) {
14858 throw new Error("initializeWasm() must be awaited first!");
14860 const nativeResponseValue = wasm.TS_COption_EventZ_none();
14861 return nativeResponseValue;
14863 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
14865 export function COption_EventZ_free(_res: bigint): void {
14866 if(!isWasmInitialized) {
14867 throw new Error("initializeWasm() must be awaited first!");
14869 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
14870 // debug statements here
14872 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
14874 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
14875 if(!isWasmInitialized) {
14876 throw new Error("initializeWasm() must be awaited first!");
14878 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
14879 return nativeResponseValue;
14881 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
14883 export function COption_EventZ_clone(orig: bigint): bigint {
14884 if(!isWasmInitialized) {
14885 throw new Error("initializeWasm() must be awaited first!");
14887 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
14888 return nativeResponseValue;
14890 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
14892 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
14893 if(!isWasmInitialized) {
14894 throw new Error("initializeWasm() must be awaited first!");
14896 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
14897 return nativeResponseValue;
14899 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
14901 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
14902 if(!isWasmInitialized) {
14903 throw new Error("initializeWasm() must be awaited first!");
14905 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
14906 return nativeResponseValue;
14908 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
14910 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
14911 if(!isWasmInitialized) {
14912 throw new Error("initializeWasm() must be awaited first!");
14914 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
14915 return nativeResponseValue;
14917 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
14919 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
14920 if(!isWasmInitialized) {
14921 throw new Error("initializeWasm() must be awaited first!");
14923 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
14924 // debug statements here
14926 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
14928 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14929 if(!isWasmInitialized) {
14930 throw new Error("initializeWasm() must be awaited first!");
14932 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
14933 return nativeResponseValue;
14935 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
14937 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
14938 if(!isWasmInitialized) {
14939 throw new Error("initializeWasm() must be awaited first!");
14941 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
14942 return nativeResponseValue;
14944 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
14946 export function CVec_MessageSendEventZ_free(_res: number): void {
14947 if(!isWasmInitialized) {
14948 throw new Error("initializeWasm() must be awaited first!");
14950 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
14951 // debug statements here
14953 // void CVec_ChainHashZ_free(struct LDKCVec_ChainHashZ _res);
14955 export function CVec_ChainHashZ_free(_res: number): void {
14956 if(!isWasmInitialized) {
14957 throw new Error("initializeWasm() must be awaited first!");
14959 const nativeResponseValue = wasm.TS_CVec_ChainHashZ_free(_res);
14960 // debug statements here
14962 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_ok(struct LDKOffer o);
14964 export function CResult_OfferBolt12ParseErrorZ_ok(o: bigint): bigint {
14965 if(!isWasmInitialized) {
14966 throw new Error("initializeWasm() must be awaited first!");
14968 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_ok(o);
14969 return nativeResponseValue;
14971 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
14973 export function CResult_OfferBolt12ParseErrorZ_err(e: bigint): bigint {
14974 if(!isWasmInitialized) {
14975 throw new Error("initializeWasm() must be awaited first!");
14977 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_err(e);
14978 return nativeResponseValue;
14980 // bool CResult_OfferBolt12ParseErrorZ_is_ok(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR o);
14982 export function CResult_OfferBolt12ParseErrorZ_is_ok(o: bigint): boolean {
14983 if(!isWasmInitialized) {
14984 throw new Error("initializeWasm() must be awaited first!");
14986 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_is_ok(o);
14987 return nativeResponseValue;
14989 // void CResult_OfferBolt12ParseErrorZ_free(struct LDKCResult_OfferBolt12ParseErrorZ _res);
14991 export function CResult_OfferBolt12ParseErrorZ_free(_res: bigint): void {
14992 if(!isWasmInitialized) {
14993 throw new Error("initializeWasm() must be awaited first!");
14995 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_free(_res);
14996 // debug statements here
14998 // uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg);
15000 export function CResult_OfferBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
15001 if(!isWasmInitialized) {
15002 throw new Error("initializeWasm() must be awaited first!");
15004 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(arg);
15005 return nativeResponseValue;
15007 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_clone(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR orig);
15009 export function CResult_OfferBolt12ParseErrorZ_clone(orig: bigint): bigint {
15010 if(!isWasmInitialized) {
15011 throw new Error("initializeWasm() must be awaited first!");
15013 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone(orig);
15014 return nativeResponseValue;
15016 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
15018 export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
15019 if(!isWasmInitialized) {
15020 throw new Error("initializeWasm() must be awaited first!");
15022 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
15023 return nativeResponseValue;
15025 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
15027 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
15028 if(!isWasmInitialized) {
15029 throw new Error("initializeWasm() must be awaited first!");
15031 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
15032 return nativeResponseValue;
15034 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
15036 export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
15037 if(!isWasmInitialized) {
15038 throw new Error("initializeWasm() must be awaited first!");
15040 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
15041 return nativeResponseValue;
15043 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
15045 export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
15046 if(!isWasmInitialized) {
15047 throw new Error("initializeWasm() must be awaited first!");
15049 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
15050 // debug statements here
15052 // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
15054 export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
15055 if(!isWasmInitialized) {
15056 throw new Error("initializeWasm() must be awaited first!");
15058 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
15059 return nativeResponseValue;
15061 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
15063 export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
15064 if(!isWasmInitialized) {
15065 throw new Error("initializeWasm() must be awaited first!");
15067 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
15068 return nativeResponseValue;
15070 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
15072 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
15073 if(!isWasmInitialized) {
15074 throw new Error("initializeWasm() must be awaited first!");
15076 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
15077 return nativeResponseValue;
15079 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
15081 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
15082 if(!isWasmInitialized) {
15083 throw new Error("initializeWasm() must be awaited first!");
15085 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
15086 return nativeResponseValue;
15088 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
15090 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
15091 if(!isWasmInitialized) {
15092 throw new Error("initializeWasm() must be awaited first!");
15094 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
15095 return nativeResponseValue;
15097 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
15099 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
15100 if(!isWasmInitialized) {
15101 throw new Error("initializeWasm() must be awaited first!");
15103 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
15104 // debug statements here
15106 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
15108 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15109 if(!isWasmInitialized) {
15110 throw new Error("initializeWasm() must be awaited first!");
15112 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
15113 return nativeResponseValue;
15115 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
15117 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
15118 if(!isWasmInitialized) {
15119 throw new Error("initializeWasm() must be awaited first!");
15121 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
15122 return nativeResponseValue;
15124 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
15126 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
15127 if(!isWasmInitialized) {
15128 throw new Error("initializeWasm() must be awaited first!");
15130 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
15131 return nativeResponseValue;
15133 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
15135 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
15136 if(!isWasmInitialized) {
15137 throw new Error("initializeWasm() must be awaited first!");
15139 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
15140 return nativeResponseValue;
15142 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
15144 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
15145 if(!isWasmInitialized) {
15146 throw new Error("initializeWasm() must be awaited first!");
15148 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
15149 return nativeResponseValue;
15151 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
15153 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
15154 if(!isWasmInitialized) {
15155 throw new Error("initializeWasm() must be awaited first!");
15157 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
15158 // debug statements here
15160 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
15162 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15163 if(!isWasmInitialized) {
15164 throw new Error("initializeWasm() must be awaited first!");
15166 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
15167 return nativeResponseValue;
15169 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
15171 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
15172 if(!isWasmInitialized) {
15173 throw new Error("initializeWasm() must be awaited first!");
15175 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
15176 return nativeResponseValue;
15178 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_some(struct LDKUtxoLookup o);
15180 export function COption_UtxoLookupZ_some(o: bigint): bigint {
15181 if(!isWasmInitialized) {
15182 throw new Error("initializeWasm() must be awaited first!");
15184 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_some(o);
15185 return nativeResponseValue;
15187 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_none(void);
15189 export function COption_UtxoLookupZ_none(): bigint {
15190 if(!isWasmInitialized) {
15191 throw new Error("initializeWasm() must be awaited first!");
15193 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_none();
15194 return nativeResponseValue;
15196 // void COption_UtxoLookupZ_free(struct LDKCOption_UtxoLookupZ _res);
15198 export function COption_UtxoLookupZ_free(_res: bigint): void {
15199 if(!isWasmInitialized) {
15200 throw new Error("initializeWasm() must be awaited first!");
15202 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_free(_res);
15203 // debug statements here
15205 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
15207 export function CResult_NoneLightningErrorZ_ok(): bigint {
15208 if(!isWasmInitialized) {
15209 throw new Error("initializeWasm() must be awaited first!");
15211 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
15212 return nativeResponseValue;
15214 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
15216 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
15217 if(!isWasmInitialized) {
15218 throw new Error("initializeWasm() must be awaited first!");
15220 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
15221 return nativeResponseValue;
15223 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
15225 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
15226 if(!isWasmInitialized) {
15227 throw new Error("initializeWasm() must be awaited first!");
15229 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
15230 return nativeResponseValue;
15232 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
15234 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
15235 if(!isWasmInitialized) {
15236 throw new Error("initializeWasm() must be awaited first!");
15238 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
15239 // debug statements here
15241 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
15243 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
15244 if(!isWasmInitialized) {
15245 throw new Error("initializeWasm() must be awaited first!");
15247 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
15248 return nativeResponseValue;
15250 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
15252 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
15253 if(!isWasmInitialized) {
15254 throw new Error("initializeWasm() must be awaited first!");
15256 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
15257 return nativeResponseValue;
15259 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
15261 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
15262 if(!isWasmInitialized) {
15263 throw new Error("initializeWasm() must be awaited first!");
15265 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
15266 return nativeResponseValue;
15268 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
15270 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
15271 if(!isWasmInitialized) {
15272 throw new Error("initializeWasm() must be awaited first!");
15274 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
15275 return nativeResponseValue;
15277 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
15279 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
15280 if(!isWasmInitialized) {
15281 throw new Error("initializeWasm() must be awaited first!");
15283 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
15284 return nativeResponseValue;
15286 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
15288 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
15289 if(!isWasmInitialized) {
15290 throw new Error("initializeWasm() must be awaited first!");
15292 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
15293 // debug statements here
15295 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
15297 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
15298 if(!isWasmInitialized) {
15299 throw new Error("initializeWasm() must be awaited first!");
15301 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
15302 return nativeResponseValue;
15304 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
15306 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
15307 if(!isWasmInitialized) {
15308 throw new Error("initializeWasm() must be awaited first!");
15310 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
15311 return nativeResponseValue;
15313 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
15315 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
15316 if(!isWasmInitialized) {
15317 throw new Error("initializeWasm() must be awaited first!");
15319 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
15320 return nativeResponseValue;
15322 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
15324 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
15325 if(!isWasmInitialized) {
15326 throw new Error("initializeWasm() must be awaited first!");
15328 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
15329 return nativeResponseValue;
15331 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
15333 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
15334 if(!isWasmInitialized) {
15335 throw new Error("initializeWasm() must be awaited first!");
15337 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
15338 return nativeResponseValue;
15340 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
15342 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
15343 if(!isWasmInitialized) {
15344 throw new Error("initializeWasm() must be awaited first!");
15346 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
15347 // debug statements here
15349 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
15351 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
15352 if(!isWasmInitialized) {
15353 throw new Error("initializeWasm() must be awaited first!");
15355 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
15356 return nativeResponseValue;
15358 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
15360 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
15361 if(!isWasmInitialized) {
15362 throw new Error("initializeWasm() must be awaited first!");
15364 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
15365 return nativeResponseValue;
15367 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
15369 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
15370 if(!isWasmInitialized) {
15371 throw new Error("initializeWasm() must be awaited first!");
15373 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
15374 // debug statements here
15376 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
15378 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
15379 if(!isWasmInitialized) {
15380 throw new Error("initializeWasm() must be awaited first!");
15382 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
15383 return nativeResponseValue;
15385 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
15387 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
15388 if(!isWasmInitialized) {
15389 throw new Error("initializeWasm() must be awaited first!");
15391 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
15392 return nativeResponseValue;
15394 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
15396 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
15397 if(!isWasmInitialized) {
15398 throw new Error("initializeWasm() must be awaited first!");
15400 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
15401 return nativeResponseValue;
15403 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
15405 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
15406 if(!isWasmInitialized) {
15407 throw new Error("initializeWasm() must be awaited first!");
15409 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
15410 return nativeResponseValue;
15412 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
15414 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15415 if(!isWasmInitialized) {
15416 throw new Error("initializeWasm() must be awaited first!");
15418 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
15419 return nativeResponseValue;
15421 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
15423 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
15424 if(!isWasmInitialized) {
15425 throw new Error("initializeWasm() must be awaited first!");
15427 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
15428 // debug statements here
15430 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
15432 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15433 if(!isWasmInitialized) {
15434 throw new Error("initializeWasm() must be awaited first!");
15436 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
15437 return nativeResponseValue;
15439 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
15441 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
15442 if(!isWasmInitialized) {
15443 throw new Error("initializeWasm() must be awaited first!");
15445 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
15446 return nativeResponseValue;
15448 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
15450 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
15451 if(!isWasmInitialized) {
15452 throw new Error("initializeWasm() must be awaited first!");
15454 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
15455 return nativeResponseValue;
15457 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
15459 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
15460 if(!isWasmInitialized) {
15461 throw new Error("initializeWasm() must be awaited first!");
15463 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
15464 return nativeResponseValue;
15466 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
15468 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15469 if(!isWasmInitialized) {
15470 throw new Error("initializeWasm() must be awaited first!");
15472 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
15473 return nativeResponseValue;
15475 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
15477 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
15478 if(!isWasmInitialized) {
15479 throw new Error("initializeWasm() must be awaited first!");
15481 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
15482 // debug statements here
15484 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
15486 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15487 if(!isWasmInitialized) {
15488 throw new Error("initializeWasm() must be awaited first!");
15490 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
15491 return nativeResponseValue;
15493 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
15495 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
15496 if(!isWasmInitialized) {
15497 throw new Error("initializeWasm() must be awaited first!");
15499 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
15500 return nativeResponseValue;
15502 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
15504 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
15505 if(!isWasmInitialized) {
15506 throw new Error("initializeWasm() must be awaited first!");
15508 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
15509 return nativeResponseValue;
15511 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
15513 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
15514 if(!isWasmInitialized) {
15515 throw new Error("initializeWasm() must be awaited first!");
15517 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
15518 return nativeResponseValue;
15520 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
15522 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
15523 if(!isWasmInitialized) {
15524 throw new Error("initializeWasm() must be awaited first!");
15526 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
15527 return nativeResponseValue;
15529 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
15531 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
15532 if(!isWasmInitialized) {
15533 throw new Error("initializeWasm() must be awaited first!");
15535 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
15536 // debug statements here
15538 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
15540 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15541 if(!isWasmInitialized) {
15542 throw new Error("initializeWasm() must be awaited first!");
15544 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
15545 return nativeResponseValue;
15547 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
15549 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
15550 if(!isWasmInitialized) {
15551 throw new Error("initializeWasm() must be awaited first!");
15553 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
15554 return nativeResponseValue;
15556 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
15558 export function CVec_NetAddressZ_free(_res: number): void {
15559 if(!isWasmInitialized) {
15560 throw new Error("initializeWasm() must be awaited first!");
15562 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
15563 // debug statements here
15565 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
15567 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
15568 if(!isWasmInitialized) {
15569 throw new Error("initializeWasm() must be awaited first!");
15571 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
15572 return nativeResponseValue;
15574 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
15576 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
15577 if(!isWasmInitialized) {
15578 throw new Error("initializeWasm() must be awaited first!");
15580 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
15581 return nativeResponseValue;
15583 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
15585 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15586 if(!isWasmInitialized) {
15587 throw new Error("initializeWasm() must be awaited first!");
15589 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
15590 return nativeResponseValue;
15592 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
15594 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
15595 if(!isWasmInitialized) {
15596 throw new Error("initializeWasm() must be awaited first!");
15598 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
15599 // debug statements here
15601 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
15603 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15604 if(!isWasmInitialized) {
15605 throw new Error("initializeWasm() must be awaited first!");
15607 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
15608 return nativeResponseValue;
15610 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
15612 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
15613 if(!isWasmInitialized) {
15614 throw new Error("initializeWasm() must be awaited first!");
15616 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
15617 return nativeResponseValue;
15619 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
15621 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
15622 if(!isWasmInitialized) {
15623 throw new Error("initializeWasm() must be awaited first!");
15625 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
15626 return nativeResponseValue;
15628 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
15630 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
15631 if(!isWasmInitialized) {
15632 throw new Error("initializeWasm() must be awaited first!");
15634 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
15635 return nativeResponseValue;
15637 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
15639 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
15640 if(!isWasmInitialized) {
15641 throw new Error("initializeWasm() must be awaited first!");
15643 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
15644 return nativeResponseValue;
15646 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
15648 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
15649 if(!isWasmInitialized) {
15650 throw new Error("initializeWasm() must be awaited first!");
15652 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
15653 // debug statements here
15655 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
15657 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15658 if(!isWasmInitialized) {
15659 throw new Error("initializeWasm() must be awaited first!");
15661 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
15662 return nativeResponseValue;
15664 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
15666 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
15667 if(!isWasmInitialized) {
15668 throw new Error("initializeWasm() must be awaited first!");
15670 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
15671 return nativeResponseValue;
15673 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
15675 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
15676 if(!isWasmInitialized) {
15677 throw new Error("initializeWasm() must be awaited first!");
15679 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
15680 return nativeResponseValue;
15682 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
15684 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
15685 if(!isWasmInitialized) {
15686 throw new Error("initializeWasm() must be awaited first!");
15688 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
15689 return nativeResponseValue;
15691 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
15693 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15694 if(!isWasmInitialized) {
15695 throw new Error("initializeWasm() must be awaited first!");
15697 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
15698 return nativeResponseValue;
15700 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
15702 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
15703 if(!isWasmInitialized) {
15704 throw new Error("initializeWasm() must be awaited first!");
15706 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
15707 // debug statements here
15709 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
15711 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15712 if(!isWasmInitialized) {
15713 throw new Error("initializeWasm() must be awaited first!");
15715 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
15716 return nativeResponseValue;
15718 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
15720 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
15721 if(!isWasmInitialized) {
15722 throw new Error("initializeWasm() must be awaited first!");
15724 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
15725 return nativeResponseValue;
15727 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
15729 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
15730 if(!isWasmInitialized) {
15731 throw new Error("initializeWasm() must be awaited first!");
15733 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
15734 return nativeResponseValue;
15736 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
15738 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
15739 if(!isWasmInitialized) {
15740 throw new Error("initializeWasm() must be awaited first!");
15742 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
15743 return nativeResponseValue;
15745 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
15747 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
15748 if(!isWasmInitialized) {
15749 throw new Error("initializeWasm() must be awaited first!");
15751 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
15752 return nativeResponseValue;
15754 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
15756 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
15757 if(!isWasmInitialized) {
15758 throw new Error("initializeWasm() must be awaited first!");
15760 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
15761 // debug statements here
15763 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
15765 export function COption_CVec_NetAddressZZ_some(o: number): bigint {
15766 if(!isWasmInitialized) {
15767 throw new Error("initializeWasm() must be awaited first!");
15769 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
15770 return nativeResponseValue;
15772 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
15774 export function COption_CVec_NetAddressZZ_none(): bigint {
15775 if(!isWasmInitialized) {
15776 throw new Error("initializeWasm() must be awaited first!");
15778 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
15779 return nativeResponseValue;
15781 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
15783 export function COption_CVec_NetAddressZZ_free(_res: bigint): void {
15784 if(!isWasmInitialized) {
15785 throw new Error("initializeWasm() must be awaited first!");
15787 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
15788 // debug statements here
15790 // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
15792 export function COption_CVec_NetAddressZZ_clone_ptr(arg: bigint): bigint {
15793 if(!isWasmInitialized) {
15794 throw new Error("initializeWasm() must be awaited first!");
15796 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
15797 return nativeResponseValue;
15799 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
15801 export function COption_CVec_NetAddressZZ_clone(orig: bigint): bigint {
15802 if(!isWasmInitialized) {
15803 throw new Error("initializeWasm() must be awaited first!");
15805 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
15806 return nativeResponseValue;
15808 // void CVec_HTLCOutputInCommitmentZ_free(struct LDKCVec_HTLCOutputInCommitmentZ _res);
15810 export function CVec_HTLCOutputInCommitmentZ_free(_res: number): void {
15811 if(!isWasmInitialized) {
15812 throw new Error("initializeWasm() must be awaited first!");
15814 const nativeResponseValue = wasm.TS_CVec_HTLCOutputInCommitmentZ_free(_res);
15815 // debug statements here
15817 // void CVec_HTLCDescriptorZ_free(struct LDKCVec_HTLCDescriptorZ _res);
15819 export function CVec_HTLCDescriptorZ_free(_res: number): void {
15820 if(!isWasmInitialized) {
15821 throw new Error("initializeWasm() must be awaited first!");
15823 const nativeResponseValue = wasm.TS_CVec_HTLCDescriptorZ_free(_res);
15824 // debug statements here
15826 // void CVec_UtxoZ_free(struct LDKCVec_UtxoZ _res);
15828 export function CVec_UtxoZ_free(_res: number): void {
15829 if(!isWasmInitialized) {
15830 throw new Error("initializeWasm() must be awaited first!");
15832 const nativeResponseValue = wasm.TS_CVec_UtxoZ_free(_res);
15833 // debug statements here
15835 // struct LDKCOption_TxOutZ COption_TxOutZ_some(struct LDKTxOut o);
15837 export function COption_TxOutZ_some(o: bigint): bigint {
15838 if(!isWasmInitialized) {
15839 throw new Error("initializeWasm() must be awaited first!");
15841 const nativeResponseValue = wasm.TS_COption_TxOutZ_some(o);
15842 return nativeResponseValue;
15844 // struct LDKCOption_TxOutZ COption_TxOutZ_none(void);
15846 export function COption_TxOutZ_none(): bigint {
15847 if(!isWasmInitialized) {
15848 throw new Error("initializeWasm() must be awaited first!");
15850 const nativeResponseValue = wasm.TS_COption_TxOutZ_none();
15851 return nativeResponseValue;
15853 // void COption_TxOutZ_free(struct LDKCOption_TxOutZ _res);
15855 export function COption_TxOutZ_free(_res: bigint): void {
15856 if(!isWasmInitialized) {
15857 throw new Error("initializeWasm() must be awaited first!");
15859 const nativeResponseValue = wasm.TS_COption_TxOutZ_free(_res);
15860 // debug statements here
15862 // uint64_t COption_TxOutZ_clone_ptr(LDKCOption_TxOutZ *NONNULL_PTR arg);
15864 export function COption_TxOutZ_clone_ptr(arg: bigint): bigint {
15865 if(!isWasmInitialized) {
15866 throw new Error("initializeWasm() must be awaited first!");
15868 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone_ptr(arg);
15869 return nativeResponseValue;
15871 // struct LDKCOption_TxOutZ COption_TxOutZ_clone(const struct LDKCOption_TxOutZ *NONNULL_PTR orig);
15873 export function COption_TxOutZ_clone(orig: bigint): bigint {
15874 if(!isWasmInitialized) {
15875 throw new Error("initializeWasm() must be awaited first!");
15877 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone(orig);
15878 return nativeResponseValue;
15880 // void CVec_InputZ_free(struct LDKCVec_InputZ _res);
15882 export function CVec_InputZ_free(_res: number): void {
15883 if(!isWasmInitialized) {
15884 throw new Error("initializeWasm() must be awaited first!");
15886 const nativeResponseValue = wasm.TS_CVec_InputZ_free(_res);
15887 // debug statements here
15889 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_ok(struct LDKCoinSelection o);
15891 export function CResult_CoinSelectionNoneZ_ok(o: bigint): bigint {
15892 if(!isWasmInitialized) {
15893 throw new Error("initializeWasm() must be awaited first!");
15895 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_ok(o);
15896 return nativeResponseValue;
15898 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_err(void);
15900 export function CResult_CoinSelectionNoneZ_err(): bigint {
15901 if(!isWasmInitialized) {
15902 throw new Error("initializeWasm() must be awaited first!");
15904 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_err();
15905 return nativeResponseValue;
15907 // bool CResult_CoinSelectionNoneZ_is_ok(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR o);
15909 export function CResult_CoinSelectionNoneZ_is_ok(o: bigint): boolean {
15910 if(!isWasmInitialized) {
15911 throw new Error("initializeWasm() must be awaited first!");
15913 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_is_ok(o);
15914 return nativeResponseValue;
15916 // void CResult_CoinSelectionNoneZ_free(struct LDKCResult_CoinSelectionNoneZ _res);
15918 export function CResult_CoinSelectionNoneZ_free(_res: bigint): void {
15919 if(!isWasmInitialized) {
15920 throw new Error("initializeWasm() must be awaited first!");
15922 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_free(_res);
15923 // debug statements here
15925 // uint64_t CResult_CoinSelectionNoneZ_clone_ptr(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR arg);
15927 export function CResult_CoinSelectionNoneZ_clone_ptr(arg: bigint): bigint {
15928 if(!isWasmInitialized) {
15929 throw new Error("initializeWasm() must be awaited first!");
15931 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone_ptr(arg);
15932 return nativeResponseValue;
15934 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_clone(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR orig);
15936 export function CResult_CoinSelectionNoneZ_clone(orig: bigint): bigint {
15937 if(!isWasmInitialized) {
15938 throw new Error("initializeWasm() must be awaited first!");
15940 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone(orig);
15941 return nativeResponseValue;
15943 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_ok(struct LDKCVec_UtxoZ o);
15945 export function CResult_CVec_UtxoZNoneZ_ok(o: number): bigint {
15946 if(!isWasmInitialized) {
15947 throw new Error("initializeWasm() must be awaited first!");
15949 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_ok(o);
15950 return nativeResponseValue;
15952 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_err(void);
15954 export function CResult_CVec_UtxoZNoneZ_err(): bigint {
15955 if(!isWasmInitialized) {
15956 throw new Error("initializeWasm() must be awaited first!");
15958 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_err();
15959 return nativeResponseValue;
15961 // bool CResult_CVec_UtxoZNoneZ_is_ok(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR o);
15963 export function CResult_CVec_UtxoZNoneZ_is_ok(o: bigint): boolean {
15964 if(!isWasmInitialized) {
15965 throw new Error("initializeWasm() must be awaited first!");
15967 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_is_ok(o);
15968 return nativeResponseValue;
15970 // void CResult_CVec_UtxoZNoneZ_free(struct LDKCResult_CVec_UtxoZNoneZ _res);
15972 export function CResult_CVec_UtxoZNoneZ_free(_res: bigint): void {
15973 if(!isWasmInitialized) {
15974 throw new Error("initializeWasm() must be awaited first!");
15976 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_free(_res);
15977 // debug statements here
15979 // uint64_t CResult_CVec_UtxoZNoneZ_clone_ptr(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR arg);
15981 export function CResult_CVec_UtxoZNoneZ_clone_ptr(arg: bigint): bigint {
15982 if(!isWasmInitialized) {
15983 throw new Error("initializeWasm() must be awaited first!");
15985 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone_ptr(arg);
15986 return nativeResponseValue;
15988 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_clone(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR orig);
15990 export function CResult_CVec_UtxoZNoneZ_clone(orig: bigint): bigint {
15991 if(!isWasmInitialized) {
15992 throw new Error("initializeWasm() must be awaited first!");
15994 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone(orig);
15995 return nativeResponseValue;
15997 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
15999 export function COption_u16Z_some(o: number): bigint {
16000 if(!isWasmInitialized) {
16001 throw new Error("initializeWasm() must be awaited first!");
16003 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
16004 return nativeResponseValue;
16006 // struct LDKCOption_u16Z COption_u16Z_none(void);
16008 export function COption_u16Z_none(): bigint {
16009 if(!isWasmInitialized) {
16010 throw new Error("initializeWasm() must be awaited first!");
16012 const nativeResponseValue = wasm.TS_COption_u16Z_none();
16013 return nativeResponseValue;
16015 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
16017 export function COption_u16Z_free(_res: bigint): void {
16018 if(!isWasmInitialized) {
16019 throw new Error("initializeWasm() must be awaited first!");
16021 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
16022 // debug statements here
16024 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
16026 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
16027 if(!isWasmInitialized) {
16028 throw new Error("initializeWasm() must be awaited first!");
16030 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
16031 return nativeResponseValue;
16033 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
16035 export function COption_u16Z_clone(orig: bigint): bigint {
16036 if(!isWasmInitialized) {
16037 throw new Error("initializeWasm() must be awaited first!");
16039 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
16040 return nativeResponseValue;
16042 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
16044 export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
16045 if(!isWasmInitialized) {
16046 throw new Error("initializeWasm() must be awaited first!");
16048 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
16049 return nativeResponseValue;
16051 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
16053 export function COption_ChannelShutdownStateZ_none(): bigint {
16054 if(!isWasmInitialized) {
16055 throw new Error("initializeWasm() must be awaited first!");
16057 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
16058 return nativeResponseValue;
16060 // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
16062 export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
16063 if(!isWasmInitialized) {
16064 throw new Error("initializeWasm() must be awaited first!");
16066 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
16067 // debug statements here
16069 // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
16071 export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
16072 if(!isWasmInitialized) {
16073 throw new Error("initializeWasm() must be awaited first!");
16075 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
16076 return nativeResponseValue;
16078 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
16080 export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
16081 if(!isWasmInitialized) {
16082 throw new Error("initializeWasm() must be awaited first!");
16084 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
16085 return nativeResponseValue;
16087 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
16089 export function CResult__u832APIErrorZ_ok(o: number): bigint {
16090 if(!isWasmInitialized) {
16091 throw new Error("initializeWasm() must be awaited first!");
16093 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
16094 return nativeResponseValue;
16096 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
16098 export function CResult__u832APIErrorZ_err(e: bigint): bigint {
16099 if(!isWasmInitialized) {
16100 throw new Error("initializeWasm() must be awaited first!");
16102 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
16103 return nativeResponseValue;
16105 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
16107 export function CResult__u832APIErrorZ_is_ok(o: bigint): boolean {
16108 if(!isWasmInitialized) {
16109 throw new Error("initializeWasm() must be awaited first!");
16111 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
16112 return nativeResponseValue;
16114 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
16116 export function CResult__u832APIErrorZ_free(_res: bigint): void {
16117 if(!isWasmInitialized) {
16118 throw new Error("initializeWasm() must be awaited first!");
16120 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
16121 // debug statements here
16123 // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
16125 export function CResult__u832APIErrorZ_clone_ptr(arg: bigint): bigint {
16126 if(!isWasmInitialized) {
16127 throw new Error("initializeWasm() must be awaited first!");
16129 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
16130 return nativeResponseValue;
16132 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
16134 export function CResult__u832APIErrorZ_clone(orig: bigint): bigint {
16135 if(!isWasmInitialized) {
16136 throw new Error("initializeWasm() must be awaited first!");
16138 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
16139 return nativeResponseValue;
16141 // void CVec_RecentPaymentDetailsZ_free(struct LDKCVec_RecentPaymentDetailsZ _res);
16143 export function CVec_RecentPaymentDetailsZ_free(_res: number): void {
16144 if(!isWasmInitialized) {
16145 throw new Error("initializeWasm() must be awaited first!");
16147 const nativeResponseValue = wasm.TS_CVec_RecentPaymentDetailsZ_free(_res);
16148 // debug statements here
16150 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
16152 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
16153 if(!isWasmInitialized) {
16154 throw new Error("initializeWasm() must be awaited first!");
16156 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
16157 return nativeResponseValue;
16159 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
16161 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
16162 if(!isWasmInitialized) {
16163 throw new Error("initializeWasm() must be awaited first!");
16165 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
16166 return nativeResponseValue;
16168 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
16170 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
16171 if(!isWasmInitialized) {
16172 throw new Error("initializeWasm() must be awaited first!");
16174 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
16175 return nativeResponseValue;
16177 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
16179 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
16180 if(!isWasmInitialized) {
16181 throw new Error("initializeWasm() must be awaited first!");
16183 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
16184 // debug statements here
16186 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
16188 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
16189 if(!isWasmInitialized) {
16190 throw new Error("initializeWasm() must be awaited first!");
16192 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
16193 return nativeResponseValue;
16195 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
16197 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
16198 if(!isWasmInitialized) {
16199 throw new Error("initializeWasm() must be awaited first!");
16201 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
16202 return nativeResponseValue;
16204 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_ok(void);
16206 export function CResult_NoneRetryableSendFailureZ_ok(): bigint {
16207 if(!isWasmInitialized) {
16208 throw new Error("initializeWasm() must be awaited first!");
16210 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_ok();
16211 return nativeResponseValue;
16213 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
16215 export function CResult_NoneRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
16216 if(!isWasmInitialized) {
16217 throw new Error("initializeWasm() must be awaited first!");
16219 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_err(e);
16220 return nativeResponseValue;
16222 // bool CResult_NoneRetryableSendFailureZ_is_ok(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR o);
16224 export function CResult_NoneRetryableSendFailureZ_is_ok(o: bigint): boolean {
16225 if(!isWasmInitialized) {
16226 throw new Error("initializeWasm() must be awaited first!");
16228 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_is_ok(o);
16229 return nativeResponseValue;
16231 // void CResult_NoneRetryableSendFailureZ_free(struct LDKCResult_NoneRetryableSendFailureZ _res);
16233 export function CResult_NoneRetryableSendFailureZ_free(_res: bigint): void {
16234 if(!isWasmInitialized) {
16235 throw new Error("initializeWasm() must be awaited first!");
16237 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_free(_res);
16238 // debug statements here
16240 // uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg);
16242 export function CResult_NoneRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
16243 if(!isWasmInitialized) {
16244 throw new Error("initializeWasm() must be awaited first!");
16246 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone_ptr(arg);
16247 return nativeResponseValue;
16249 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_clone(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR orig);
16251 export function CResult_NoneRetryableSendFailureZ_clone(orig: bigint): bigint {
16252 if(!isWasmInitialized) {
16253 throw new Error("initializeWasm() must be awaited first!");
16255 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone(orig);
16256 return nativeResponseValue;
16258 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
16260 export function CResult_PaymentHashPaymentSendFailureZ_ok(o: number): bigint {
16261 if(!isWasmInitialized) {
16262 throw new Error("initializeWasm() must be awaited first!");
16264 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_ok(o);
16265 return nativeResponseValue;
16267 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
16269 export function CResult_PaymentHashPaymentSendFailureZ_err(e: bigint): bigint {
16270 if(!isWasmInitialized) {
16271 throw new Error("initializeWasm() must be awaited first!");
16273 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_err(e);
16274 return nativeResponseValue;
16276 // bool CResult_PaymentHashPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR o);
16278 export function CResult_PaymentHashPaymentSendFailureZ_is_ok(o: bigint): boolean {
16279 if(!isWasmInitialized) {
16280 throw new Error("initializeWasm() must be awaited first!");
16282 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_is_ok(o);
16283 return nativeResponseValue;
16285 // void CResult_PaymentHashPaymentSendFailureZ_free(struct LDKCResult_PaymentHashPaymentSendFailureZ _res);
16287 export function CResult_PaymentHashPaymentSendFailureZ_free(_res: bigint): void {
16288 if(!isWasmInitialized) {
16289 throw new Error("initializeWasm() must be awaited first!");
16291 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_free(_res);
16292 // debug statements here
16294 // uint64_t CResult_PaymentHashPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR arg);
16296 export function CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
16297 if(!isWasmInitialized) {
16298 throw new Error("initializeWasm() must be awaited first!");
16300 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg);
16301 return nativeResponseValue;
16303 // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_clone(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR orig);
16305 export function CResult_PaymentHashPaymentSendFailureZ_clone(orig: bigint): bigint {
16306 if(!isWasmInitialized) {
16307 throw new Error("initializeWasm() must be awaited first!");
16309 const nativeResponseValue = wasm.TS_CResult_PaymentHashPaymentSendFailureZ_clone(orig);
16310 return nativeResponseValue;
16312 // struct LDKCResult_PaymentHashRetryableSendFailureZ CResult_PaymentHashRetryableSendFailureZ_ok(struct LDKThirtyTwoBytes o);
16314 export function CResult_PaymentHashRetryableSendFailureZ_ok(o: number): bigint {
16315 if(!isWasmInitialized) {
16316 throw new Error("initializeWasm() must be awaited first!");
16318 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_ok(o);
16319 return nativeResponseValue;
16321 // struct LDKCResult_PaymentHashRetryableSendFailureZ CResult_PaymentHashRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
16323 export function CResult_PaymentHashRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
16324 if(!isWasmInitialized) {
16325 throw new Error("initializeWasm() must be awaited first!");
16327 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_err(e);
16328 return nativeResponseValue;
16330 // bool CResult_PaymentHashRetryableSendFailureZ_is_ok(const struct LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR o);
16332 export function CResult_PaymentHashRetryableSendFailureZ_is_ok(o: bigint): boolean {
16333 if(!isWasmInitialized) {
16334 throw new Error("initializeWasm() must be awaited first!");
16336 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_is_ok(o);
16337 return nativeResponseValue;
16339 // void CResult_PaymentHashRetryableSendFailureZ_free(struct LDKCResult_PaymentHashRetryableSendFailureZ _res);
16341 export function CResult_PaymentHashRetryableSendFailureZ_free(_res: bigint): void {
16342 if(!isWasmInitialized) {
16343 throw new Error("initializeWasm() must be awaited first!");
16345 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_free(_res);
16346 // debug statements here
16348 // uint64_t CResult_PaymentHashRetryableSendFailureZ_clone_ptr(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR arg);
16350 export function CResult_PaymentHashRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
16351 if(!isWasmInitialized) {
16352 throw new Error("initializeWasm() must be awaited first!");
16354 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_clone_ptr(arg);
16355 return nativeResponseValue;
16357 // struct LDKCResult_PaymentHashRetryableSendFailureZ CResult_PaymentHashRetryableSendFailureZ_clone(const struct LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR orig);
16359 export function CResult_PaymentHashRetryableSendFailureZ_clone(orig: bigint): bigint {
16360 if(!isWasmInitialized) {
16361 throw new Error("initializeWasm() must be awaited first!");
16363 const nativeResponseValue = wasm.TS_CResult_PaymentHashRetryableSendFailureZ_clone(orig);
16364 return nativeResponseValue;
16366 // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
16368 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: bigint): bigint {
16369 if(!isWasmInitialized) {
16370 throw new Error("initializeWasm() must be awaited first!");
16372 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
16373 return nativeResponseValue;
16375 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
16377 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: bigint): bigint {
16378 if(!isWasmInitialized) {
16379 throw new Error("initializeWasm() must be awaited first!");
16381 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
16382 return nativeResponseValue;
16384 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
16386 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): bigint {
16387 if(!isWasmInitialized) {
16388 throw new Error("initializeWasm() must be awaited first!");
16390 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
16391 return nativeResponseValue;
16393 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
16395 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: bigint): void {
16396 if(!isWasmInitialized) {
16397 throw new Error("initializeWasm() must be awaited first!");
16399 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
16400 // debug statements here
16402 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
16404 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: bigint): bigint {
16405 if(!isWasmInitialized) {
16406 throw new Error("initializeWasm() must be awaited first!");
16408 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
16409 return nativeResponseValue;
16411 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
16413 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: bigint): bigint {
16414 if(!isWasmInitialized) {
16415 throw new Error("initializeWasm() must be awaited first!");
16417 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
16418 return nativeResponseValue;
16420 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
16422 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: bigint): boolean {
16423 if(!isWasmInitialized) {
16424 throw new Error("initializeWasm() must be awaited first!");
16426 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
16427 return nativeResponseValue;
16429 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
16431 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: bigint): void {
16432 if(!isWasmInitialized) {
16433 throw new Error("initializeWasm() must be awaited first!");
16435 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
16436 // debug statements here
16438 // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
16440 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
16441 if(!isWasmInitialized) {
16442 throw new Error("initializeWasm() must be awaited first!");
16444 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
16445 return nativeResponseValue;
16447 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
16449 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: bigint): bigint {
16450 if(!isWasmInitialized) {
16451 throw new Error("initializeWasm() must be awaited first!");
16453 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
16454 return nativeResponseValue;
16456 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
16458 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
16459 if(!isWasmInitialized) {
16460 throw new Error("initializeWasm() must be awaited first!");
16462 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
16463 // debug statements here
16465 // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
16467 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: bigint): bigint {
16468 if(!isWasmInitialized) {
16469 throw new Error("initializeWasm() must be awaited first!");
16471 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
16472 return nativeResponseValue;
16474 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
16476 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: bigint): bigint {
16477 if(!isWasmInitialized) {
16478 throw new Error("initializeWasm() must be awaited first!");
16480 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
16481 return nativeResponseValue;
16483 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
16485 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): bigint {
16486 if(!isWasmInitialized) {
16487 throw new Error("initializeWasm() must be awaited first!");
16489 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
16490 return nativeResponseValue;
16492 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
16494 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: bigint): void {
16495 if(!isWasmInitialized) {
16496 throw new Error("initializeWasm() must be awaited first!");
16498 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
16499 // debug statements here
16501 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
16503 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: bigint): bigint {
16504 if(!isWasmInitialized) {
16505 throw new Error("initializeWasm() must be awaited first!");
16507 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
16508 return nativeResponseValue;
16510 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
16512 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): bigint {
16513 if(!isWasmInitialized) {
16514 throw new Error("initializeWasm() must be awaited first!");
16516 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
16517 return nativeResponseValue;
16519 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
16521 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: bigint): boolean {
16522 if(!isWasmInitialized) {
16523 throw new Error("initializeWasm() must be awaited first!");
16525 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
16526 return nativeResponseValue;
16528 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
16530 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: bigint): void {
16531 if(!isWasmInitialized) {
16532 throw new Error("initializeWasm() must be awaited first!");
16534 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
16535 // debug statements here
16537 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
16539 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: bigint): bigint {
16540 if(!isWasmInitialized) {
16541 throw new Error("initializeWasm() must be awaited first!");
16543 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
16544 return nativeResponseValue;
16546 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
16548 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: bigint): bigint {
16549 if(!isWasmInitialized) {
16550 throw new Error("initializeWasm() must be awaited first!");
16552 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
16553 return nativeResponseValue;
16555 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
16557 export function CResult_PaymentSecretNoneZ_ok(o: number): bigint {
16558 if(!isWasmInitialized) {
16559 throw new Error("initializeWasm() must be awaited first!");
16561 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
16562 return nativeResponseValue;
16564 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
16566 export function CResult_PaymentSecretNoneZ_err(): bigint {
16567 if(!isWasmInitialized) {
16568 throw new Error("initializeWasm() must be awaited first!");
16570 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
16571 return nativeResponseValue;
16573 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
16575 export function CResult_PaymentSecretNoneZ_is_ok(o: bigint): boolean {
16576 if(!isWasmInitialized) {
16577 throw new Error("initializeWasm() must be awaited first!");
16579 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
16580 return nativeResponseValue;
16582 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
16584 export function CResult_PaymentSecretNoneZ_free(_res: bigint): void {
16585 if(!isWasmInitialized) {
16586 throw new Error("initializeWasm() must be awaited first!");
16588 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
16589 // debug statements here
16591 // uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
16593 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: bigint): bigint {
16594 if(!isWasmInitialized) {
16595 throw new Error("initializeWasm() must be awaited first!");
16597 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
16598 return nativeResponseValue;
16600 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
16602 export function CResult_PaymentSecretNoneZ_clone(orig: bigint): bigint {
16603 if(!isWasmInitialized) {
16604 throw new Error("initializeWasm() must be awaited first!");
16606 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
16607 return nativeResponseValue;
16609 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
16611 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): bigint {
16612 if(!isWasmInitialized) {
16613 throw new Error("initializeWasm() must be awaited first!");
16615 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
16616 return nativeResponseValue;
16618 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
16620 export function CResult_PaymentPreimageAPIErrorZ_err(e: bigint): bigint {
16621 if(!isWasmInitialized) {
16622 throw new Error("initializeWasm() must be awaited first!");
16624 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
16625 return nativeResponseValue;
16627 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
16629 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: bigint): boolean {
16630 if(!isWasmInitialized) {
16631 throw new Error("initializeWasm() must be awaited first!");
16633 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
16634 return nativeResponseValue;
16636 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
16638 export function CResult_PaymentPreimageAPIErrorZ_free(_res: bigint): void {
16639 if(!isWasmInitialized) {
16640 throw new Error("initializeWasm() must be awaited first!");
16642 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
16643 // debug statements here
16645 // uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
16647 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: bigint): bigint {
16648 if(!isWasmInitialized) {
16649 throw new Error("initializeWasm() must be awaited first!");
16651 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
16652 return nativeResponseValue;
16654 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
16656 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: bigint): bigint {
16657 if(!isWasmInitialized) {
16658 throw new Error("initializeWasm() must be awaited first!");
16660 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
16661 return nativeResponseValue;
16663 // struct LDKCOption_CVec_ChainHashZZ COption_CVec_ChainHashZZ_some(struct LDKCVec_ChainHashZ o);
16665 export function COption_CVec_ChainHashZZ_some(o: number): bigint {
16666 if(!isWasmInitialized) {
16667 throw new Error("initializeWasm() must be awaited first!");
16669 const nativeResponseValue = wasm.TS_COption_CVec_ChainHashZZ_some(o);
16670 return nativeResponseValue;
16672 // struct LDKCOption_CVec_ChainHashZZ COption_CVec_ChainHashZZ_none(void);
16674 export function COption_CVec_ChainHashZZ_none(): bigint {
16675 if(!isWasmInitialized) {
16676 throw new Error("initializeWasm() must be awaited first!");
16678 const nativeResponseValue = wasm.TS_COption_CVec_ChainHashZZ_none();
16679 return nativeResponseValue;
16681 // void COption_CVec_ChainHashZZ_free(struct LDKCOption_CVec_ChainHashZZ _res);
16683 export function COption_CVec_ChainHashZZ_free(_res: bigint): void {
16684 if(!isWasmInitialized) {
16685 throw new Error("initializeWasm() must be awaited first!");
16687 const nativeResponseValue = wasm.TS_COption_CVec_ChainHashZZ_free(_res);
16688 // debug statements here
16690 // uint64_t COption_CVec_ChainHashZZ_clone_ptr(LDKCOption_CVec_ChainHashZZ *NONNULL_PTR arg);
16692 export function COption_CVec_ChainHashZZ_clone_ptr(arg: bigint): bigint {
16693 if(!isWasmInitialized) {
16694 throw new Error("initializeWasm() must be awaited first!");
16696 const nativeResponseValue = wasm.TS_COption_CVec_ChainHashZZ_clone_ptr(arg);
16697 return nativeResponseValue;
16699 // struct LDKCOption_CVec_ChainHashZZ COption_CVec_ChainHashZZ_clone(const struct LDKCOption_CVec_ChainHashZZ *NONNULL_PTR orig);
16701 export function COption_CVec_ChainHashZZ_clone(orig: bigint): bigint {
16702 if(!isWasmInitialized) {
16703 throw new Error("initializeWasm() must be awaited first!");
16705 const nativeResponseValue = wasm.TS_COption_CVec_ChainHashZZ_clone(orig);
16706 return nativeResponseValue;
16708 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
16710 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
16711 if(!isWasmInitialized) {
16712 throw new Error("initializeWasm() must be awaited first!");
16714 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
16715 return nativeResponseValue;
16717 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
16719 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
16720 if(!isWasmInitialized) {
16721 throw new Error("initializeWasm() must be awaited first!");
16723 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
16724 return nativeResponseValue;
16726 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
16728 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
16729 if(!isWasmInitialized) {
16730 throw new Error("initializeWasm() must be awaited first!");
16732 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
16733 return nativeResponseValue;
16735 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
16737 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
16738 if(!isWasmInitialized) {
16739 throw new Error("initializeWasm() must be awaited first!");
16741 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
16742 // debug statements here
16744 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
16746 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16747 if(!isWasmInitialized) {
16748 throw new Error("initializeWasm() must be awaited first!");
16750 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
16751 return nativeResponseValue;
16753 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
16755 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
16756 if(!isWasmInitialized) {
16757 throw new Error("initializeWasm() must be awaited first!");
16759 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
16760 return nativeResponseValue;
16762 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
16764 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
16765 if(!isWasmInitialized) {
16766 throw new Error("initializeWasm() must be awaited first!");
16768 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
16769 return nativeResponseValue;
16771 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
16773 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
16774 if(!isWasmInitialized) {
16775 throw new Error("initializeWasm() must be awaited first!");
16777 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
16778 return nativeResponseValue;
16780 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
16782 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
16783 if(!isWasmInitialized) {
16784 throw new Error("initializeWasm() must be awaited first!");
16786 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
16787 return nativeResponseValue;
16789 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
16791 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
16792 if(!isWasmInitialized) {
16793 throw new Error("initializeWasm() must be awaited first!");
16795 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
16796 // debug statements here
16798 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
16800 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16801 if(!isWasmInitialized) {
16802 throw new Error("initializeWasm() must be awaited first!");
16804 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
16805 return nativeResponseValue;
16807 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
16809 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
16810 if(!isWasmInitialized) {
16811 throw new Error("initializeWasm() must be awaited first!");
16813 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
16814 return nativeResponseValue;
16816 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
16818 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
16819 if(!isWasmInitialized) {
16820 throw new Error("initializeWasm() must be awaited first!");
16822 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
16823 return nativeResponseValue;
16825 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
16827 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
16828 if(!isWasmInitialized) {
16829 throw new Error("initializeWasm() must be awaited first!");
16831 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
16832 return nativeResponseValue;
16834 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
16836 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
16837 if(!isWasmInitialized) {
16838 throw new Error("initializeWasm() must be awaited first!");
16840 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
16841 return nativeResponseValue;
16843 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
16845 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
16846 if(!isWasmInitialized) {
16847 throw new Error("initializeWasm() must be awaited first!");
16849 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
16850 // debug statements here
16852 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
16854 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16855 if(!isWasmInitialized) {
16856 throw new Error("initializeWasm() must be awaited first!");
16858 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
16859 return nativeResponseValue;
16861 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
16863 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
16864 if(!isWasmInitialized) {
16865 throw new Error("initializeWasm() must be awaited first!");
16867 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
16868 return nativeResponseValue;
16870 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
16872 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
16873 if(!isWasmInitialized) {
16874 throw new Error("initializeWasm() must be awaited first!");
16876 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
16877 return nativeResponseValue;
16879 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
16881 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
16882 if(!isWasmInitialized) {
16883 throw new Error("initializeWasm() must be awaited first!");
16885 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
16886 return nativeResponseValue;
16888 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
16890 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
16891 if(!isWasmInitialized) {
16892 throw new Error("initializeWasm() must be awaited first!");
16894 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
16895 return nativeResponseValue;
16897 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
16899 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
16900 if(!isWasmInitialized) {
16901 throw new Error("initializeWasm() must be awaited first!");
16903 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
16904 // debug statements here
16906 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
16908 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16909 if(!isWasmInitialized) {
16910 throw new Error("initializeWasm() must be awaited first!");
16912 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
16913 return nativeResponseValue;
16915 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
16917 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
16918 if(!isWasmInitialized) {
16919 throw new Error("initializeWasm() must be awaited first!");
16921 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
16922 return nativeResponseValue;
16924 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
16926 export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
16927 if(!isWasmInitialized) {
16928 throw new Error("initializeWasm() must be awaited first!");
16930 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
16931 return nativeResponseValue;
16933 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
16935 export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
16936 if(!isWasmInitialized) {
16937 throw new Error("initializeWasm() must be awaited first!");
16939 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
16940 return nativeResponseValue;
16942 // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
16944 export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
16945 if(!isWasmInitialized) {
16946 throw new Error("initializeWasm() must be awaited first!");
16948 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
16949 return nativeResponseValue;
16951 // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
16953 export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
16954 if(!isWasmInitialized) {
16955 throw new Error("initializeWasm() must be awaited first!");
16957 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
16958 // debug statements here
16960 // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
16962 export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16963 if(!isWasmInitialized) {
16964 throw new Error("initializeWasm() must be awaited first!");
16966 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
16967 return nativeResponseValue;
16969 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
16971 export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
16972 if(!isWasmInitialized) {
16973 throw new Error("initializeWasm() must be awaited first!");
16975 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
16976 return nativeResponseValue;
16978 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
16980 export function CVec_ChannelMonitorZ_free(_res: number): void {
16981 if(!isWasmInitialized) {
16982 throw new Error("initializeWasm() must be awaited first!");
16984 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
16985 // debug statements here
16987 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
16989 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: bigint): bigint {
16990 if(!isWasmInitialized) {
16991 throw new Error("initializeWasm() must be awaited first!");
16993 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
16994 return nativeResponseValue;
16996 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
16998 export function C2Tuple_BlockHashChannelManagerZ_free(_res: bigint): void {
16999 if(!isWasmInitialized) {
17000 throw new Error("initializeWasm() must be awaited first!");
17002 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
17003 // debug statements here
17005 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
17007 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
17008 if(!isWasmInitialized) {
17009 throw new Error("initializeWasm() must be awaited first!");
17011 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
17012 return nativeResponseValue;
17014 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
17016 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
17017 if(!isWasmInitialized) {
17018 throw new Error("initializeWasm() must be awaited first!");
17020 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
17021 return nativeResponseValue;
17023 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
17025 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
17026 if(!isWasmInitialized) {
17027 throw new Error("initializeWasm() must be awaited first!");
17029 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
17030 return nativeResponseValue;
17032 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
17034 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: bigint): void {
17035 if(!isWasmInitialized) {
17036 throw new Error("initializeWasm() must be awaited first!");
17038 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
17039 // debug statements here
17041 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_ok(struct LDKMaxDustHTLCExposure o);
17043 export function CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o: bigint): bigint {
17044 if(!isWasmInitialized) {
17045 throw new Error("initializeWasm() must be awaited first!");
17047 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o);
17048 return nativeResponseValue;
17050 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_err(struct LDKDecodeError e);
17052 export function CResult_MaxDustHTLCExposureDecodeErrorZ_err(e: bigint): bigint {
17053 if(!isWasmInitialized) {
17054 throw new Error("initializeWasm() must be awaited first!");
17056 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err(e);
17057 return nativeResponseValue;
17059 // bool CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR o);
17061 export function CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o: bigint): boolean {
17062 if(!isWasmInitialized) {
17063 throw new Error("initializeWasm() must be awaited first!");
17065 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o);
17066 return nativeResponseValue;
17068 // void CResult_MaxDustHTLCExposureDecodeErrorZ_free(struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ _res);
17070 export function CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res: bigint): void {
17071 if(!isWasmInitialized) {
17072 throw new Error("initializeWasm() must be awaited first!");
17074 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res);
17075 // debug statements here
17077 // uint64_t CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR arg);
17079 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17080 if(!isWasmInitialized) {
17081 throw new Error("initializeWasm() must be awaited first!");
17083 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg);
17084 return nativeResponseValue;
17086 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_clone(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR orig);
17088 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig: bigint): bigint {
17089 if(!isWasmInitialized) {
17090 throw new Error("initializeWasm() must be awaited first!");
17092 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig);
17093 return nativeResponseValue;
17095 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
17097 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
17098 if(!isWasmInitialized) {
17099 throw new Error("initializeWasm() must be awaited first!");
17101 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
17102 return nativeResponseValue;
17104 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
17106 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
17107 if(!isWasmInitialized) {
17108 throw new Error("initializeWasm() must be awaited first!");
17110 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
17111 return nativeResponseValue;
17113 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
17115 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
17116 if(!isWasmInitialized) {
17117 throw new Error("initializeWasm() must be awaited first!");
17119 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
17120 return nativeResponseValue;
17122 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
17124 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
17125 if(!isWasmInitialized) {
17126 throw new Error("initializeWasm() must be awaited first!");
17128 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
17129 // debug statements here
17131 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
17133 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17134 if(!isWasmInitialized) {
17135 throw new Error("initializeWasm() must be awaited first!");
17137 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
17138 return nativeResponseValue;
17140 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
17142 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
17143 if(!isWasmInitialized) {
17144 throw new Error("initializeWasm() must be awaited first!");
17146 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
17147 return nativeResponseValue;
17149 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_some(struct LDKMaxDustHTLCExposure o);
17151 export function COption_MaxDustHTLCExposureZ_some(o: bigint): bigint {
17152 if(!isWasmInitialized) {
17153 throw new Error("initializeWasm() must be awaited first!");
17155 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_some(o);
17156 return nativeResponseValue;
17158 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_none(void);
17160 export function COption_MaxDustHTLCExposureZ_none(): bigint {
17161 if(!isWasmInitialized) {
17162 throw new Error("initializeWasm() must be awaited first!");
17164 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_none();
17165 return nativeResponseValue;
17167 // void COption_MaxDustHTLCExposureZ_free(struct LDKCOption_MaxDustHTLCExposureZ _res);
17169 export function COption_MaxDustHTLCExposureZ_free(_res: bigint): void {
17170 if(!isWasmInitialized) {
17171 throw new Error("initializeWasm() must be awaited first!");
17173 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_free(_res);
17174 // debug statements here
17176 // uint64_t COption_MaxDustHTLCExposureZ_clone_ptr(LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR arg);
17178 export function COption_MaxDustHTLCExposureZ_clone_ptr(arg: bigint): bigint {
17179 if(!isWasmInitialized) {
17180 throw new Error("initializeWasm() must be awaited first!");
17182 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone_ptr(arg);
17183 return nativeResponseValue;
17185 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_clone(const struct LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR orig);
17187 export function COption_MaxDustHTLCExposureZ_clone(orig: bigint): bigint {
17188 if(!isWasmInitialized) {
17189 throw new Error("initializeWasm() must be awaited first!");
17191 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone(orig);
17192 return nativeResponseValue;
17194 // struct LDKCOption_APIErrorZ COption_APIErrorZ_some(struct LDKAPIError o);
17196 export function COption_APIErrorZ_some(o: bigint): bigint {
17197 if(!isWasmInitialized) {
17198 throw new Error("initializeWasm() must be awaited first!");
17200 const nativeResponseValue = wasm.TS_COption_APIErrorZ_some(o);
17201 return nativeResponseValue;
17203 // struct LDKCOption_APIErrorZ COption_APIErrorZ_none(void);
17205 export function COption_APIErrorZ_none(): bigint {
17206 if(!isWasmInitialized) {
17207 throw new Error("initializeWasm() must be awaited first!");
17209 const nativeResponseValue = wasm.TS_COption_APIErrorZ_none();
17210 return nativeResponseValue;
17212 // void COption_APIErrorZ_free(struct LDKCOption_APIErrorZ _res);
17214 export function COption_APIErrorZ_free(_res: bigint): void {
17215 if(!isWasmInitialized) {
17216 throw new Error("initializeWasm() must be awaited first!");
17218 const nativeResponseValue = wasm.TS_COption_APIErrorZ_free(_res);
17219 // debug statements here
17221 // uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg);
17223 export function COption_APIErrorZ_clone_ptr(arg: bigint): bigint {
17224 if(!isWasmInitialized) {
17225 throw new Error("initializeWasm() must be awaited first!");
17227 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone_ptr(arg);
17228 return nativeResponseValue;
17230 // struct LDKCOption_APIErrorZ COption_APIErrorZ_clone(const struct LDKCOption_APIErrorZ *NONNULL_PTR orig);
17232 export function COption_APIErrorZ_clone(orig: bigint): bigint {
17233 if(!isWasmInitialized) {
17234 throw new Error("initializeWasm() must be awaited first!");
17236 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone(orig);
17237 return nativeResponseValue;
17239 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_ok(struct LDKCOption_APIErrorZ o);
17241 export function CResult_COption_APIErrorZDecodeErrorZ_ok(o: bigint): bigint {
17242 if(!isWasmInitialized) {
17243 throw new Error("initializeWasm() must be awaited first!");
17245 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_ok(o);
17246 return nativeResponseValue;
17248 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_err(struct LDKDecodeError e);
17250 export function CResult_COption_APIErrorZDecodeErrorZ_err(e: bigint): bigint {
17251 if(!isWasmInitialized) {
17252 throw new Error("initializeWasm() must be awaited first!");
17254 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_err(e);
17255 return nativeResponseValue;
17257 // bool CResult_COption_APIErrorZDecodeErrorZ_is_ok(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR o);
17259 export function CResult_COption_APIErrorZDecodeErrorZ_is_ok(o: bigint): boolean {
17260 if(!isWasmInitialized) {
17261 throw new Error("initializeWasm() must be awaited first!");
17263 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(o);
17264 return nativeResponseValue;
17266 // void CResult_COption_APIErrorZDecodeErrorZ_free(struct LDKCResult_COption_APIErrorZDecodeErrorZ _res);
17268 export function CResult_COption_APIErrorZDecodeErrorZ_free(_res: bigint): void {
17269 if(!isWasmInitialized) {
17270 throw new Error("initializeWasm() must be awaited first!");
17272 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_free(_res);
17273 // debug statements here
17275 // uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg);
17277 export function CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17278 if(!isWasmInitialized) {
17279 throw new Error("initializeWasm() must be awaited first!");
17281 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg);
17282 return nativeResponseValue;
17284 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_clone(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR orig);
17286 export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigint {
17287 if(!isWasmInitialized) {
17288 throw new Error("initializeWasm() must be awaited first!");
17290 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
17291 return nativeResponseValue;
17293 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_ok(struct LDKBigSize o);
17295 export function CResult_BigSizeDecodeErrorZ_ok(o: bigint): bigint {
17296 if(!isWasmInitialized) {
17297 throw new Error("initializeWasm() must be awaited first!");
17299 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_ok(o);
17300 return nativeResponseValue;
17302 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_err(struct LDKDecodeError e);
17304 export function CResult_BigSizeDecodeErrorZ_err(e: bigint): bigint {
17305 if(!isWasmInitialized) {
17306 throw new Error("initializeWasm() must be awaited first!");
17308 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_err(e);
17309 return nativeResponseValue;
17311 // bool CResult_BigSizeDecodeErrorZ_is_ok(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR o);
17313 export function CResult_BigSizeDecodeErrorZ_is_ok(o: bigint): boolean {
17314 if(!isWasmInitialized) {
17315 throw new Error("initializeWasm() must be awaited first!");
17317 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_is_ok(o);
17318 return nativeResponseValue;
17320 // void CResult_BigSizeDecodeErrorZ_free(struct LDKCResult_BigSizeDecodeErrorZ _res);
17322 export function CResult_BigSizeDecodeErrorZ_free(_res: bigint): void {
17323 if(!isWasmInitialized) {
17324 throw new Error("initializeWasm() must be awaited first!");
17326 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_free(_res);
17327 // debug statements here
17329 // uint64_t CResult_BigSizeDecodeErrorZ_clone_ptr(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR arg);
17331 export function CResult_BigSizeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17332 if(!isWasmInitialized) {
17333 throw new Error("initializeWasm() must be awaited first!");
17335 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone_ptr(arg);
17336 return nativeResponseValue;
17338 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_clone(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR orig);
17340 export function CResult_BigSizeDecodeErrorZ_clone(orig: bigint): bigint {
17341 if(!isWasmInitialized) {
17342 throw new Error("initializeWasm() must be awaited first!");
17344 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone(orig);
17345 return nativeResponseValue;
17347 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_ok(struct LDKHostname o);
17349 export function CResult_HostnameDecodeErrorZ_ok(o: bigint): bigint {
17350 if(!isWasmInitialized) {
17351 throw new Error("initializeWasm() must be awaited first!");
17353 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_ok(o);
17354 return nativeResponseValue;
17356 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_err(struct LDKDecodeError e);
17358 export function CResult_HostnameDecodeErrorZ_err(e: bigint): bigint {
17359 if(!isWasmInitialized) {
17360 throw new Error("initializeWasm() must be awaited first!");
17362 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_err(e);
17363 return nativeResponseValue;
17365 // bool CResult_HostnameDecodeErrorZ_is_ok(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR o);
17367 export function CResult_HostnameDecodeErrorZ_is_ok(o: bigint): boolean {
17368 if(!isWasmInitialized) {
17369 throw new Error("initializeWasm() must be awaited first!");
17371 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_is_ok(o);
17372 return nativeResponseValue;
17374 // void CResult_HostnameDecodeErrorZ_free(struct LDKCResult_HostnameDecodeErrorZ _res);
17376 export function CResult_HostnameDecodeErrorZ_free(_res: bigint): void {
17377 if(!isWasmInitialized) {
17378 throw new Error("initializeWasm() must be awaited first!");
17380 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_free(_res);
17381 // debug statements here
17383 // uint64_t CResult_HostnameDecodeErrorZ_clone_ptr(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR arg);
17385 export function CResult_HostnameDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17386 if(!isWasmInitialized) {
17387 throw new Error("initializeWasm() must be awaited first!");
17389 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone_ptr(arg);
17390 return nativeResponseValue;
17392 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_clone(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR orig);
17394 export function CResult_HostnameDecodeErrorZ_clone(orig: bigint): bigint {
17395 if(!isWasmInitialized) {
17396 throw new Error("initializeWasm() must be awaited first!");
17398 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone(orig);
17399 return nativeResponseValue;
17401 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_ok(struct LDKTransactionU16LenLimited o);
17403 export function CResult_TransactionU16LenLimitedNoneZ_ok(o: bigint): bigint {
17404 if(!isWasmInitialized) {
17405 throw new Error("initializeWasm() must be awaited first!");
17407 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_ok(o);
17408 return nativeResponseValue;
17410 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_err(void);
17412 export function CResult_TransactionU16LenLimitedNoneZ_err(): bigint {
17413 if(!isWasmInitialized) {
17414 throw new Error("initializeWasm() must be awaited first!");
17416 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_err();
17417 return nativeResponseValue;
17419 // bool CResult_TransactionU16LenLimitedNoneZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR o);
17421 export function CResult_TransactionU16LenLimitedNoneZ_is_ok(o: bigint): boolean {
17422 if(!isWasmInitialized) {
17423 throw new Error("initializeWasm() must be awaited first!");
17425 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_is_ok(o);
17426 return nativeResponseValue;
17428 // void CResult_TransactionU16LenLimitedNoneZ_free(struct LDKCResult_TransactionU16LenLimitedNoneZ _res);
17430 export function CResult_TransactionU16LenLimitedNoneZ_free(_res: bigint): void {
17431 if(!isWasmInitialized) {
17432 throw new Error("initializeWasm() must be awaited first!");
17434 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_free(_res);
17435 // debug statements here
17437 // uint64_t CResult_TransactionU16LenLimitedNoneZ_clone_ptr(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR arg);
17439 export function CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg: bigint): bigint {
17440 if(!isWasmInitialized) {
17441 throw new Error("initializeWasm() must be awaited first!");
17443 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg);
17444 return nativeResponseValue;
17446 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_clone(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR orig);
17448 export function CResult_TransactionU16LenLimitedNoneZ_clone(orig: bigint): bigint {
17449 if(!isWasmInitialized) {
17450 throw new Error("initializeWasm() must be awaited first!");
17452 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone(orig);
17453 return nativeResponseValue;
17455 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_ok(struct LDKTransactionU16LenLimited o);
17457 export function CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o: bigint): bigint {
17458 if(!isWasmInitialized) {
17459 throw new Error("initializeWasm() must be awaited first!");
17461 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o);
17462 return nativeResponseValue;
17464 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_err(struct LDKDecodeError e);
17466 export function CResult_TransactionU16LenLimitedDecodeErrorZ_err(e: bigint): bigint {
17467 if(!isWasmInitialized) {
17468 throw new Error("initializeWasm() must be awaited first!");
17470 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err(e);
17471 return nativeResponseValue;
17473 // bool CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR o);
17475 export function CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o: bigint): boolean {
17476 if(!isWasmInitialized) {
17477 throw new Error("initializeWasm() must be awaited first!");
17479 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o);
17480 return nativeResponseValue;
17482 // void CResult_TransactionU16LenLimitedDecodeErrorZ_free(struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ _res);
17484 export function CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res: bigint): void {
17485 if(!isWasmInitialized) {
17486 throw new Error("initializeWasm() must be awaited first!");
17488 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res);
17489 // debug statements here
17491 // uint64_t CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR arg);
17493 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17494 if(!isWasmInitialized) {
17495 throw new Error("initializeWasm() must be awaited first!");
17497 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg);
17498 return nativeResponseValue;
17500 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_clone(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR orig);
17502 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig: bigint): bigint {
17503 if(!isWasmInitialized) {
17504 throw new Error("initializeWasm() must be awaited first!");
17506 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig);
17507 return nativeResponseValue;
17509 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_ok(struct LDKUntrustedString o);
17511 export function CResult_UntrustedStringDecodeErrorZ_ok(o: bigint): bigint {
17512 if(!isWasmInitialized) {
17513 throw new Error("initializeWasm() must be awaited first!");
17515 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_ok(o);
17516 return nativeResponseValue;
17518 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_err(struct LDKDecodeError e);
17520 export function CResult_UntrustedStringDecodeErrorZ_err(e: bigint): bigint {
17521 if(!isWasmInitialized) {
17522 throw new Error("initializeWasm() must be awaited first!");
17524 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_err(e);
17525 return nativeResponseValue;
17527 // bool CResult_UntrustedStringDecodeErrorZ_is_ok(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR o);
17529 export function CResult_UntrustedStringDecodeErrorZ_is_ok(o: bigint): boolean {
17530 if(!isWasmInitialized) {
17531 throw new Error("initializeWasm() must be awaited first!");
17533 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_is_ok(o);
17534 return nativeResponseValue;
17536 // void CResult_UntrustedStringDecodeErrorZ_free(struct LDKCResult_UntrustedStringDecodeErrorZ _res);
17538 export function CResult_UntrustedStringDecodeErrorZ_free(_res: bigint): void {
17539 if(!isWasmInitialized) {
17540 throw new Error("initializeWasm() must be awaited first!");
17542 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_free(_res);
17543 // debug statements here
17545 // uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg);
17547 export function CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17548 if(!isWasmInitialized) {
17549 throw new Error("initializeWasm() must be awaited first!");
17551 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg);
17552 return nativeResponseValue;
17554 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_clone(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR orig);
17556 export function CResult_UntrustedStringDecodeErrorZ_clone(orig: bigint): bigint {
17557 if(!isWasmInitialized) {
17558 throw new Error("initializeWasm() must be awaited first!");
17560 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone(orig);
17561 return nativeResponseValue;
17563 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
17565 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
17566 if(!isWasmInitialized) {
17567 throw new Error("initializeWasm() must be awaited first!");
17569 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
17570 return nativeResponseValue;
17572 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
17574 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
17575 if(!isWasmInitialized) {
17576 throw new Error("initializeWasm() must be awaited first!");
17578 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
17579 return nativeResponseValue;
17581 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
17583 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
17584 if(!isWasmInitialized) {
17585 throw new Error("initializeWasm() must be awaited first!");
17587 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
17588 return nativeResponseValue;
17590 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
17592 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
17593 if(!isWasmInitialized) {
17594 throw new Error("initializeWasm() must be awaited first!");
17596 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
17597 // debug statements here
17599 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
17601 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17602 if(!isWasmInitialized) {
17603 throw new Error("initializeWasm() must be awaited first!");
17605 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
17606 return nativeResponseValue;
17608 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
17610 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
17611 if(!isWasmInitialized) {
17612 throw new Error("initializeWasm() must be awaited first!");
17614 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
17615 return nativeResponseValue;
17617 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
17619 export function COption_TypeZ_some(o: bigint): bigint {
17620 if(!isWasmInitialized) {
17621 throw new Error("initializeWasm() must be awaited first!");
17623 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
17624 return nativeResponseValue;
17626 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
17628 export function COption_TypeZ_none(): bigint {
17629 if(!isWasmInitialized) {
17630 throw new Error("initializeWasm() must be awaited first!");
17632 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
17633 return nativeResponseValue;
17635 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
17637 export function COption_TypeZ_free(_res: bigint): void {
17638 if(!isWasmInitialized) {
17639 throw new Error("initializeWasm() must be awaited first!");
17641 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
17642 // debug statements here
17644 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
17646 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
17647 if(!isWasmInitialized) {
17648 throw new Error("initializeWasm() must be awaited first!");
17650 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
17651 return nativeResponseValue;
17653 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
17655 export function COption_TypeZ_clone(orig: bigint): bigint {
17656 if(!isWasmInitialized) {
17657 throw new Error("initializeWasm() must be awaited first!");
17659 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
17660 return nativeResponseValue;
17662 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
17664 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
17665 if(!isWasmInitialized) {
17666 throw new Error("initializeWasm() must be awaited first!");
17668 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
17669 return nativeResponseValue;
17671 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
17673 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
17674 if(!isWasmInitialized) {
17675 throw new Error("initializeWasm() must be awaited first!");
17677 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
17678 return nativeResponseValue;
17680 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
17682 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
17683 if(!isWasmInitialized) {
17684 throw new Error("initializeWasm() must be awaited first!");
17686 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
17687 return nativeResponseValue;
17689 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
17691 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
17692 if(!isWasmInitialized) {
17693 throw new Error("initializeWasm() must be awaited first!");
17695 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
17696 // debug statements here
17698 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
17700 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17701 if(!isWasmInitialized) {
17702 throw new Error("initializeWasm() must be awaited first!");
17704 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
17705 return nativeResponseValue;
17707 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
17709 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
17710 if(!isWasmInitialized) {
17711 throw new Error("initializeWasm() must be awaited first!");
17713 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
17714 return nativeResponseValue;
17716 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
17718 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): bigint {
17719 if(!isWasmInitialized) {
17720 throw new Error("initializeWasm() must be awaited first!");
17722 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
17723 return nativeResponseValue;
17725 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
17727 export function CResult_PaymentIdPaymentErrorZ_err(e: bigint): bigint {
17728 if(!isWasmInitialized) {
17729 throw new Error("initializeWasm() must be awaited first!");
17731 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
17732 return nativeResponseValue;
17734 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
17736 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: bigint): boolean {
17737 if(!isWasmInitialized) {
17738 throw new Error("initializeWasm() must be awaited first!");
17740 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
17741 return nativeResponseValue;
17743 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
17745 export function CResult_PaymentIdPaymentErrorZ_free(_res: bigint): void {
17746 if(!isWasmInitialized) {
17747 throw new Error("initializeWasm() must be awaited first!");
17749 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
17750 // debug statements here
17752 // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
17754 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: bigint): bigint {
17755 if(!isWasmInitialized) {
17756 throw new Error("initializeWasm() must be awaited first!");
17758 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
17759 return nativeResponseValue;
17761 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
17763 export function CResult_PaymentIdPaymentErrorZ_clone(orig: bigint): bigint {
17764 if(!isWasmInitialized) {
17765 throw new Error("initializeWasm() must be awaited first!");
17767 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
17768 return nativeResponseValue;
17770 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_ok(void);
17772 export function CResult_NonePaymentErrorZ_ok(): bigint {
17773 if(!isWasmInitialized) {
17774 throw new Error("initializeWasm() must be awaited first!");
17776 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_ok();
17777 return nativeResponseValue;
17779 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_err(struct LDKPaymentError e);
17781 export function CResult_NonePaymentErrorZ_err(e: bigint): bigint {
17782 if(!isWasmInitialized) {
17783 throw new Error("initializeWasm() must be awaited first!");
17785 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_err(e);
17786 return nativeResponseValue;
17788 // bool CResult_NonePaymentErrorZ_is_ok(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR o);
17790 export function CResult_NonePaymentErrorZ_is_ok(o: bigint): boolean {
17791 if(!isWasmInitialized) {
17792 throw new Error("initializeWasm() must be awaited first!");
17794 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_is_ok(o);
17795 return nativeResponseValue;
17797 // void CResult_NonePaymentErrorZ_free(struct LDKCResult_NonePaymentErrorZ _res);
17799 export function CResult_NonePaymentErrorZ_free(_res: bigint): void {
17800 if(!isWasmInitialized) {
17801 throw new Error("initializeWasm() must be awaited first!");
17803 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_free(_res);
17804 // debug statements here
17806 // uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg);
17808 export function CResult_NonePaymentErrorZ_clone_ptr(arg: bigint): bigint {
17809 if(!isWasmInitialized) {
17810 throw new Error("initializeWasm() must be awaited first!");
17812 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone_ptr(arg);
17813 return nativeResponseValue;
17815 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_clone(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR orig);
17817 export function CResult_NonePaymentErrorZ_clone(orig: bigint): bigint {
17818 if(!isWasmInitialized) {
17819 throw new Error("initializeWasm() must be awaited first!");
17821 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone(orig);
17822 return nativeResponseValue;
17824 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
17826 export function CResult_StringErrorZ_ok(o: number): bigint {
17827 if(!isWasmInitialized) {
17828 throw new Error("initializeWasm() must be awaited first!");
17830 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
17831 return nativeResponseValue;
17833 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
17835 export function CResult_StringErrorZ_err(e: Secp256k1Error): bigint {
17836 if(!isWasmInitialized) {
17837 throw new Error("initializeWasm() must be awaited first!");
17839 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
17840 return nativeResponseValue;
17842 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
17844 export function CResult_StringErrorZ_is_ok(o: bigint): boolean {
17845 if(!isWasmInitialized) {
17846 throw new Error("initializeWasm() must be awaited first!");
17848 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
17849 return nativeResponseValue;
17851 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
17853 export function CResult_StringErrorZ_free(_res: bigint): void {
17854 if(!isWasmInitialized) {
17855 throw new Error("initializeWasm() must be awaited first!");
17857 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
17858 // debug statements here
17860 // uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
17862 export function CResult_StringErrorZ_clone_ptr(arg: bigint): bigint {
17863 if(!isWasmInitialized) {
17864 throw new Error("initializeWasm() must be awaited first!");
17866 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
17867 return nativeResponseValue;
17869 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
17871 export function CResult_StringErrorZ_clone(orig: bigint): bigint {
17872 if(!isWasmInitialized) {
17873 throw new Error("initializeWasm() must be awaited first!");
17875 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
17876 return nativeResponseValue;
17878 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
17880 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
17881 if(!isWasmInitialized) {
17882 throw new Error("initializeWasm() must be awaited first!");
17884 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
17885 return nativeResponseValue;
17887 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
17889 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
17890 if(!isWasmInitialized) {
17891 throw new Error("initializeWasm() must be awaited first!");
17893 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
17894 return nativeResponseValue;
17896 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
17898 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
17899 if(!isWasmInitialized) {
17900 throw new Error("initializeWasm() must be awaited first!");
17902 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
17903 return nativeResponseValue;
17905 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
17907 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
17908 if(!isWasmInitialized) {
17909 throw new Error("initializeWasm() must be awaited first!");
17911 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
17912 // debug statements here
17914 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
17916 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17917 if(!isWasmInitialized) {
17918 throw new Error("initializeWasm() must be awaited first!");
17920 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
17921 return nativeResponseValue;
17923 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
17925 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
17926 if(!isWasmInitialized) {
17927 throw new Error("initializeWasm() must be awaited first!");
17929 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
17930 return nativeResponseValue;
17932 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
17934 export function COption_MonitorEventZ_some(o: bigint): bigint {
17935 if(!isWasmInitialized) {
17936 throw new Error("initializeWasm() must be awaited first!");
17938 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
17939 return nativeResponseValue;
17941 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
17943 export function COption_MonitorEventZ_none(): bigint {
17944 if(!isWasmInitialized) {
17945 throw new Error("initializeWasm() must be awaited first!");
17947 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
17948 return nativeResponseValue;
17950 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
17952 export function COption_MonitorEventZ_free(_res: bigint): void {
17953 if(!isWasmInitialized) {
17954 throw new Error("initializeWasm() must be awaited first!");
17956 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
17957 // debug statements here
17959 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
17961 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
17962 if(!isWasmInitialized) {
17963 throw new Error("initializeWasm() must be awaited first!");
17965 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
17966 return nativeResponseValue;
17968 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
17970 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
17971 if(!isWasmInitialized) {
17972 throw new Error("initializeWasm() must be awaited first!");
17974 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
17975 return nativeResponseValue;
17977 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
17979 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
17980 if(!isWasmInitialized) {
17981 throw new Error("initializeWasm() must be awaited first!");
17983 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
17984 return nativeResponseValue;
17986 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
17988 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
17989 if(!isWasmInitialized) {
17990 throw new Error("initializeWasm() must be awaited first!");
17992 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
17993 return nativeResponseValue;
17995 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
17997 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
17998 if(!isWasmInitialized) {
17999 throw new Error("initializeWasm() must be awaited first!");
18001 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
18002 return nativeResponseValue;
18004 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
18006 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
18007 if(!isWasmInitialized) {
18008 throw new Error("initializeWasm() must be awaited first!");
18010 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
18011 // debug statements here
18013 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
18015 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18016 if(!isWasmInitialized) {
18017 throw new Error("initializeWasm() must be awaited first!");
18019 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
18020 return nativeResponseValue;
18022 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
18024 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
18025 if(!isWasmInitialized) {
18026 throw new Error("initializeWasm() must be awaited first!");
18028 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
18029 return nativeResponseValue;
18031 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
18033 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
18034 if(!isWasmInitialized) {
18035 throw new Error("initializeWasm() must be awaited first!");
18037 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
18038 return nativeResponseValue;
18040 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
18042 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
18043 if(!isWasmInitialized) {
18044 throw new Error("initializeWasm() must be awaited first!");
18046 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
18047 return nativeResponseValue;
18049 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
18051 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
18052 if(!isWasmInitialized) {
18053 throw new Error("initializeWasm() must be awaited first!");
18055 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
18056 return nativeResponseValue;
18058 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
18060 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
18061 if(!isWasmInitialized) {
18062 throw new Error("initializeWasm() must be awaited first!");
18064 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
18065 // debug statements here
18067 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
18069 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18070 if(!isWasmInitialized) {
18071 throw new Error("initializeWasm() must be awaited first!");
18073 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
18074 return nativeResponseValue;
18076 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
18078 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
18079 if(!isWasmInitialized) {
18080 throw new Error("initializeWasm() must be awaited first!");
18082 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
18083 return nativeResponseValue;
18085 // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
18087 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: bigint): bigint {
18088 if(!isWasmInitialized) {
18089 throw new Error("initializeWasm() must be awaited first!");
18091 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
18092 return nativeResponseValue;
18094 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
18096 export function C2Tuple_OutPointScriptZ_clone(orig: bigint): bigint {
18097 if(!isWasmInitialized) {
18098 throw new Error("initializeWasm() must be awaited first!");
18100 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
18101 return nativeResponseValue;
18103 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
18105 export function C2Tuple_OutPointScriptZ_new(a: bigint, b: number): bigint {
18106 if(!isWasmInitialized) {
18107 throw new Error("initializeWasm() must be awaited first!");
18109 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
18110 return nativeResponseValue;
18112 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
18114 export function C2Tuple_OutPointScriptZ_free(_res: bigint): void {
18115 if(!isWasmInitialized) {
18116 throw new Error("initializeWasm() must be awaited first!");
18118 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
18119 // debug statements here
18121 // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
18123 export function C2Tuple_u32ScriptZ_clone_ptr(arg: bigint): bigint {
18124 if(!isWasmInitialized) {
18125 throw new Error("initializeWasm() must be awaited first!");
18127 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
18128 return nativeResponseValue;
18130 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
18132 export function C2Tuple_u32ScriptZ_clone(orig: bigint): bigint {
18133 if(!isWasmInitialized) {
18134 throw new Error("initializeWasm() must be awaited first!");
18136 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
18137 return nativeResponseValue;
18139 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
18141 export function C2Tuple_u32ScriptZ_new(a: number, b: number): bigint {
18142 if(!isWasmInitialized) {
18143 throw new Error("initializeWasm() must be awaited first!");
18145 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
18146 return nativeResponseValue;
18148 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
18150 export function C2Tuple_u32ScriptZ_free(_res: bigint): void {
18151 if(!isWasmInitialized) {
18152 throw new Error("initializeWasm() must be awaited first!");
18154 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
18155 // debug statements here
18157 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
18159 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
18160 if(!isWasmInitialized) {
18161 throw new Error("initializeWasm() must be awaited first!");
18163 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
18164 // debug statements here
18166 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
18168 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: bigint): bigint {
18169 if(!isWasmInitialized) {
18170 throw new Error("initializeWasm() must be awaited first!");
18172 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
18173 return nativeResponseValue;
18175 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
18177 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: bigint): bigint {
18178 if(!isWasmInitialized) {
18179 throw new Error("initializeWasm() must be awaited first!");
18181 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
18182 return nativeResponseValue;
18184 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
18186 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): bigint {
18187 if(!isWasmInitialized) {
18188 throw new Error("initializeWasm() must be awaited first!");
18190 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
18191 return nativeResponseValue;
18193 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
18195 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: bigint): void {
18196 if(!isWasmInitialized) {
18197 throw new Error("initializeWasm() must be awaited first!");
18199 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
18200 // debug statements here
18202 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
18204 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
18205 if(!isWasmInitialized) {
18206 throw new Error("initializeWasm() must be awaited first!");
18208 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
18209 // debug statements here
18211 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
18213 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
18214 if(!isWasmInitialized) {
18215 throw new Error("initializeWasm() must be awaited first!");
18217 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
18218 return nativeResponseValue;
18220 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
18222 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
18223 if(!isWasmInitialized) {
18224 throw new Error("initializeWasm() must be awaited first!");
18226 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
18227 return nativeResponseValue;
18229 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
18231 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
18232 if(!isWasmInitialized) {
18233 throw new Error("initializeWasm() must be awaited first!");
18235 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
18236 return nativeResponseValue;
18238 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
18240 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
18241 if(!isWasmInitialized) {
18242 throw new Error("initializeWasm() must be awaited first!");
18244 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
18245 // debug statements here
18247 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
18249 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
18250 if(!isWasmInitialized) {
18251 throw new Error("initializeWasm() must be awaited first!");
18253 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
18254 // debug statements here
18256 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
18258 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
18259 if(!isWasmInitialized) {
18260 throw new Error("initializeWasm() must be awaited first!");
18262 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
18263 return nativeResponseValue;
18265 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
18267 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
18268 if(!isWasmInitialized) {
18269 throw new Error("initializeWasm() must be awaited first!");
18271 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
18272 return nativeResponseValue;
18274 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
18276 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
18277 if(!isWasmInitialized) {
18278 throw new Error("initializeWasm() must be awaited first!");
18280 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
18281 return nativeResponseValue;
18283 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
18285 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
18286 if(!isWasmInitialized) {
18287 throw new Error("initializeWasm() must be awaited first!");
18289 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
18290 // debug statements here
18292 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
18294 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
18295 if(!isWasmInitialized) {
18296 throw new Error("initializeWasm() must be awaited first!");
18298 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
18299 // debug statements here
18301 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
18303 export function CVec_BalanceZ_free(_res: number): void {
18304 if(!isWasmInitialized) {
18305 throw new Error("initializeWasm() must be awaited first!");
18307 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
18308 // debug statements here
18310 // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
18312 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: bigint): bigint {
18313 if(!isWasmInitialized) {
18314 throw new Error("initializeWasm() must be awaited first!");
18316 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
18317 return nativeResponseValue;
18319 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
18321 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: bigint): bigint {
18322 if(!isWasmInitialized) {
18323 throw new Error("initializeWasm() must be awaited first!");
18325 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
18326 return nativeResponseValue;
18328 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
18330 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: bigint): bigint {
18331 if(!isWasmInitialized) {
18332 throw new Error("initializeWasm() must be awaited first!");
18334 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
18335 return nativeResponseValue;
18337 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
18339 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: bigint): void {
18340 if(!isWasmInitialized) {
18341 throw new Error("initializeWasm() must be awaited first!");
18343 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
18344 // debug statements here
18346 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
18348 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
18349 if(!isWasmInitialized) {
18350 throw new Error("initializeWasm() must be awaited first!");
18352 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
18353 return nativeResponseValue;
18355 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
18357 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
18358 if(!isWasmInitialized) {
18359 throw new Error("initializeWasm() must be awaited first!");
18361 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
18362 return nativeResponseValue;
18364 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
18366 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
18367 if(!isWasmInitialized) {
18368 throw new Error("initializeWasm() must be awaited first!");
18370 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
18371 return nativeResponseValue;
18373 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
18375 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
18376 if(!isWasmInitialized) {
18377 throw new Error("initializeWasm() must be awaited first!");
18379 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
18380 // debug statements here
18382 // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
18384 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18385 if(!isWasmInitialized) {
18386 throw new Error("initializeWasm() must be awaited first!");
18388 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
18389 return nativeResponseValue;
18391 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
18393 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
18394 if(!isWasmInitialized) {
18395 throw new Error("initializeWasm() must be awaited first!");
18397 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
18398 return nativeResponseValue;
18400 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
18402 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
18403 if(!isWasmInitialized) {
18404 throw new Error("initializeWasm() must be awaited first!");
18406 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
18407 return nativeResponseValue;
18409 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
18411 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
18412 if(!isWasmInitialized) {
18413 throw new Error("initializeWasm() must be awaited first!");
18415 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
18416 return nativeResponseValue;
18418 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
18420 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
18421 if(!isWasmInitialized) {
18422 throw new Error("initializeWasm() must be awaited first!");
18424 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
18425 return nativeResponseValue;
18427 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
18429 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
18430 if(!isWasmInitialized) {
18431 throw new Error("initializeWasm() must be awaited first!");
18433 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
18434 // debug statements here
18436 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
18438 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
18439 if(!isWasmInitialized) {
18440 throw new Error("initializeWasm() must be awaited first!");
18442 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
18443 // debug statements here
18445 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_some(struct LDKCustomOnionMessageContents o);
18447 export function COption_CustomOnionMessageContentsZ_some(o: bigint): bigint {
18448 if(!isWasmInitialized) {
18449 throw new Error("initializeWasm() must be awaited first!");
18451 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_some(o);
18452 return nativeResponseValue;
18454 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_none(void);
18456 export function COption_CustomOnionMessageContentsZ_none(): bigint {
18457 if(!isWasmInitialized) {
18458 throw new Error("initializeWasm() must be awaited first!");
18460 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_none();
18461 return nativeResponseValue;
18463 // void COption_CustomOnionMessageContentsZ_free(struct LDKCOption_CustomOnionMessageContentsZ _res);
18465 export function COption_CustomOnionMessageContentsZ_free(_res: bigint): void {
18466 if(!isWasmInitialized) {
18467 throw new Error("initializeWasm() must be awaited first!");
18469 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_free(_res);
18470 // debug statements here
18472 // uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg);
18474 export function COption_CustomOnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
18475 if(!isWasmInitialized) {
18476 throw new Error("initializeWasm() must be awaited first!");
18478 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone_ptr(arg);
18479 return nativeResponseValue;
18481 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_clone(const struct LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR orig);
18483 export function COption_CustomOnionMessageContentsZ_clone(orig: bigint): bigint {
18484 if(!isWasmInitialized) {
18485 throw new Error("initializeWasm() must be awaited first!");
18487 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone(orig);
18488 return nativeResponseValue;
18490 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_CustomOnionMessageContentsZ o);
18492 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
18493 if(!isWasmInitialized) {
18494 throw new Error("initializeWasm() must be awaited first!");
18496 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o);
18497 return nativeResponseValue;
18499 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
18501 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
18502 if(!isWasmInitialized) {
18503 throw new Error("initializeWasm() must be awaited first!");
18505 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e);
18506 return nativeResponseValue;
18508 // bool CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
18510 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
18511 if(!isWasmInitialized) {
18512 throw new Error("initializeWasm() must be awaited first!");
18514 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o);
18515 return nativeResponseValue;
18517 // void CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res);
18519 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
18520 if(!isWasmInitialized) {
18521 throw new Error("initializeWasm() must be awaited first!");
18523 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res);
18524 // debug statements here
18526 // uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
18528 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18529 if(!isWasmInitialized) {
18530 throw new Error("initializeWasm() must be awaited first!");
18532 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
18533 return nativeResponseValue;
18535 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
18537 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
18538 if(!isWasmInitialized) {
18539 throw new Error("initializeWasm() must be awaited first!");
18541 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig);
18542 return nativeResponseValue;
18544 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
18546 export function COption_NetAddressZ_some(o: bigint): bigint {
18547 if(!isWasmInitialized) {
18548 throw new Error("initializeWasm() must be awaited first!");
18550 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
18551 return nativeResponseValue;
18553 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
18555 export function COption_NetAddressZ_none(): bigint {
18556 if(!isWasmInitialized) {
18557 throw new Error("initializeWasm() must be awaited first!");
18559 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
18560 return nativeResponseValue;
18562 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
18564 export function COption_NetAddressZ_free(_res: bigint): void {
18565 if(!isWasmInitialized) {
18566 throw new Error("initializeWasm() must be awaited first!");
18568 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
18569 // debug statements here
18571 // uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
18573 export function COption_NetAddressZ_clone_ptr(arg: bigint): bigint {
18574 if(!isWasmInitialized) {
18575 throw new Error("initializeWasm() must be awaited first!");
18577 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
18578 return nativeResponseValue;
18580 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
18582 export function COption_NetAddressZ_clone(orig: bigint): bigint {
18583 if(!isWasmInitialized) {
18584 throw new Error("initializeWasm() must be awaited first!");
18586 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
18587 return nativeResponseValue;
18589 // uint64_t C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR arg);
18591 export function C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(arg: bigint): bigint {
18592 if(!isWasmInitialized) {
18593 throw new Error("initializeWasm() must be awaited first!");
18595 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(arg);
18596 return nativeResponseValue;
18598 // struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ C2Tuple_PublicKeyCOption_NetAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR orig);
18600 export function C2Tuple_PublicKeyCOption_NetAddressZZ_clone(orig: bigint): bigint {
18601 if(!isWasmInitialized) {
18602 throw new Error("initializeWasm() must be awaited first!");
18604 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone(orig);
18605 return nativeResponseValue;
18607 // struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ C2Tuple_PublicKeyCOption_NetAddressZZ_new(struct LDKPublicKey a, struct LDKCOption_NetAddressZ b);
18609 export function C2Tuple_PublicKeyCOption_NetAddressZZ_new(a: number, b: bigint): bigint {
18610 if(!isWasmInitialized) {
18611 throw new Error("initializeWasm() must be awaited first!");
18613 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_new(a, b);
18614 return nativeResponseValue;
18616 // void C2Tuple_PublicKeyCOption_NetAddressZZ_free(struct LDKC2Tuple_PublicKeyCOption_NetAddressZZ _res);
18618 export function C2Tuple_PublicKeyCOption_NetAddressZZ_free(_res: bigint): void {
18619 if(!isWasmInitialized) {
18620 throw new Error("initializeWasm() must be awaited first!");
18622 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_NetAddressZZ_free(_res);
18623 // debug statements here
18625 // void CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ _res);
18627 export function CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(_res: number): void {
18628 if(!isWasmInitialized) {
18629 throw new Error("initializeWasm() must be awaited first!");
18631 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(_res);
18632 // debug statements here
18634 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
18636 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
18637 if(!isWasmInitialized) {
18638 throw new Error("initializeWasm() must be awaited first!");
18640 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
18641 return nativeResponseValue;
18643 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
18645 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
18646 if(!isWasmInitialized) {
18647 throw new Error("initializeWasm() must be awaited first!");
18649 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
18650 return nativeResponseValue;
18652 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
18654 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
18655 if(!isWasmInitialized) {
18656 throw new Error("initializeWasm() must be awaited first!");
18658 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
18659 return nativeResponseValue;
18661 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
18663 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
18664 if(!isWasmInitialized) {
18665 throw new Error("initializeWasm() must be awaited first!");
18667 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
18668 // debug statements here
18670 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
18672 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
18673 if(!isWasmInitialized) {
18674 throw new Error("initializeWasm() must be awaited first!");
18676 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
18677 return nativeResponseValue;
18679 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
18681 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
18682 if(!isWasmInitialized) {
18683 throw new Error("initializeWasm() must be awaited first!");
18685 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
18686 return nativeResponseValue;
18688 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
18690 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
18691 if(!isWasmInitialized) {
18692 throw new Error("initializeWasm() must be awaited first!");
18694 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
18695 return nativeResponseValue;
18697 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
18699 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
18700 if(!isWasmInitialized) {
18701 throw new Error("initializeWasm() must be awaited first!");
18703 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
18704 return nativeResponseValue;
18706 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
18708 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
18709 if(!isWasmInitialized) {
18710 throw new Error("initializeWasm() must be awaited first!");
18712 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
18713 return nativeResponseValue;
18715 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
18717 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
18718 if(!isWasmInitialized) {
18719 throw new Error("initializeWasm() must be awaited first!");
18721 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
18722 // debug statements here
18724 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
18726 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
18727 if(!isWasmInitialized) {
18728 throw new Error("initializeWasm() must be awaited first!");
18730 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
18731 return nativeResponseValue;
18733 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
18735 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
18736 if(!isWasmInitialized) {
18737 throw new Error("initializeWasm() must be awaited first!");
18739 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
18740 return nativeResponseValue;
18742 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
18744 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
18745 if(!isWasmInitialized) {
18746 throw new Error("initializeWasm() must be awaited first!");
18748 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
18749 return nativeResponseValue;
18751 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
18753 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
18754 if(!isWasmInitialized) {
18755 throw new Error("initializeWasm() must be awaited first!");
18757 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
18758 return nativeResponseValue;
18760 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
18762 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
18763 if(!isWasmInitialized) {
18764 throw new Error("initializeWasm() must be awaited first!");
18766 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
18767 return nativeResponseValue;
18769 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
18771 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
18772 if(!isWasmInitialized) {
18773 throw new Error("initializeWasm() must be awaited first!");
18775 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
18776 // debug statements here
18778 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
18780 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
18781 if(!isWasmInitialized) {
18782 throw new Error("initializeWasm() must be awaited first!");
18784 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
18785 return nativeResponseValue;
18787 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
18789 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
18790 if(!isWasmInitialized) {
18791 throw new Error("initializeWasm() must be awaited first!");
18793 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
18794 return nativeResponseValue;
18796 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_ok(struct LDKTxOut o);
18798 export function CResult_TxOutUtxoLookupErrorZ_ok(o: bigint): bigint {
18799 if(!isWasmInitialized) {
18800 throw new Error("initializeWasm() must be awaited first!");
18802 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_ok(o);
18803 return nativeResponseValue;
18805 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_err(enum LDKUtxoLookupError e);
18807 export function CResult_TxOutUtxoLookupErrorZ_err(e: UtxoLookupError): bigint {
18808 if(!isWasmInitialized) {
18809 throw new Error("initializeWasm() must be awaited first!");
18811 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_err(e);
18812 return nativeResponseValue;
18814 // bool CResult_TxOutUtxoLookupErrorZ_is_ok(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR o);
18816 export function CResult_TxOutUtxoLookupErrorZ_is_ok(o: bigint): boolean {
18817 if(!isWasmInitialized) {
18818 throw new Error("initializeWasm() must be awaited first!");
18820 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_is_ok(o);
18821 return nativeResponseValue;
18823 // void CResult_TxOutUtxoLookupErrorZ_free(struct LDKCResult_TxOutUtxoLookupErrorZ _res);
18825 export function CResult_TxOutUtxoLookupErrorZ_free(_res: bigint): void {
18826 if(!isWasmInitialized) {
18827 throw new Error("initializeWasm() must be awaited first!");
18829 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_free(_res);
18830 // debug statements here
18832 // uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg);
18834 export function CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg: bigint): bigint {
18835 if(!isWasmInitialized) {
18836 throw new Error("initializeWasm() must be awaited first!");
18838 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg);
18839 return nativeResponseValue;
18841 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_clone(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR orig);
18843 export function CResult_TxOutUtxoLookupErrorZ_clone(orig: bigint): bigint {
18844 if(!isWasmInitialized) {
18845 throw new Error("initializeWasm() must be awaited first!");
18847 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone(orig);
18848 return nativeResponseValue;
18850 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_ok(struct LDKOnionMessagePath o);
18852 export function CResult_OnionMessagePathNoneZ_ok(o: bigint): bigint {
18853 if(!isWasmInitialized) {
18854 throw new Error("initializeWasm() must be awaited first!");
18856 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_ok(o);
18857 return nativeResponseValue;
18859 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_err(void);
18861 export function CResult_OnionMessagePathNoneZ_err(): bigint {
18862 if(!isWasmInitialized) {
18863 throw new Error("initializeWasm() must be awaited first!");
18865 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_err();
18866 return nativeResponseValue;
18868 // bool CResult_OnionMessagePathNoneZ_is_ok(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR o);
18870 export function CResult_OnionMessagePathNoneZ_is_ok(o: bigint): boolean {
18871 if(!isWasmInitialized) {
18872 throw new Error("initializeWasm() must be awaited first!");
18874 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_is_ok(o);
18875 return nativeResponseValue;
18877 // void CResult_OnionMessagePathNoneZ_free(struct LDKCResult_OnionMessagePathNoneZ _res);
18879 export function CResult_OnionMessagePathNoneZ_free(_res: bigint): void {
18880 if(!isWasmInitialized) {
18881 throw new Error("initializeWasm() must be awaited first!");
18883 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_free(_res);
18884 // debug statements here
18886 // uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg);
18888 export function CResult_OnionMessagePathNoneZ_clone_ptr(arg: bigint): bigint {
18889 if(!isWasmInitialized) {
18890 throw new Error("initializeWasm() must be awaited first!");
18892 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone_ptr(arg);
18893 return nativeResponseValue;
18895 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_clone(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR orig);
18897 export function CResult_OnionMessagePathNoneZ_clone(orig: bigint): bigint {
18898 if(!isWasmInitialized) {
18899 throw new Error("initializeWasm() must be awaited first!");
18901 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone(orig);
18902 return nativeResponseValue;
18904 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
18906 export function CResult_NoneSendErrorZ_ok(): bigint {
18907 if(!isWasmInitialized) {
18908 throw new Error("initializeWasm() must be awaited first!");
18910 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
18911 return nativeResponseValue;
18913 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
18915 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
18916 if(!isWasmInitialized) {
18917 throw new Error("initializeWasm() must be awaited first!");
18919 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
18920 return nativeResponseValue;
18922 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
18924 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
18925 if(!isWasmInitialized) {
18926 throw new Error("initializeWasm() must be awaited first!");
18928 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
18929 return nativeResponseValue;
18931 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
18933 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
18934 if(!isWasmInitialized) {
18935 throw new Error("initializeWasm() must be awaited first!");
18937 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
18938 // debug statements here
18940 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
18942 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
18943 if(!isWasmInitialized) {
18944 throw new Error("initializeWasm() must be awaited first!");
18946 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
18947 return nativeResponseValue;
18949 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
18951 export function CResult_BlindedPathNoneZ_err(): bigint {
18952 if(!isWasmInitialized) {
18953 throw new Error("initializeWasm() must be awaited first!");
18955 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
18956 return nativeResponseValue;
18958 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
18960 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
18961 if(!isWasmInitialized) {
18962 throw new Error("initializeWasm() must be awaited first!");
18964 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
18965 return nativeResponseValue;
18967 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
18969 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
18970 if(!isWasmInitialized) {
18971 throw new Error("initializeWasm() must be awaited first!");
18973 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
18974 // debug statements here
18976 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
18978 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
18979 if(!isWasmInitialized) {
18980 throw new Error("initializeWasm() must be awaited first!");
18982 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
18983 return nativeResponseValue;
18985 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
18987 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
18988 if(!isWasmInitialized) {
18989 throw new Error("initializeWasm() must be awaited first!");
18991 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
18992 return nativeResponseValue;
18994 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
18996 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
18997 if(!isWasmInitialized) {
18998 throw new Error("initializeWasm() must be awaited first!");
19000 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
19001 return nativeResponseValue;
19003 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
19005 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
19006 if(!isWasmInitialized) {
19007 throw new Error("initializeWasm() must be awaited first!");
19009 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
19010 return nativeResponseValue;
19012 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
19014 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
19015 if(!isWasmInitialized) {
19016 throw new Error("initializeWasm() must be awaited first!");
19018 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
19019 return nativeResponseValue;
19021 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
19023 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
19024 if(!isWasmInitialized) {
19025 throw new Error("initializeWasm() must be awaited first!");
19027 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
19028 // debug statements here
19030 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
19032 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19033 if(!isWasmInitialized) {
19034 throw new Error("initializeWasm() must be awaited first!");
19036 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
19037 return nativeResponseValue;
19039 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
19041 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
19042 if(!isWasmInitialized) {
19043 throw new Error("initializeWasm() must be awaited first!");
19045 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
19046 return nativeResponseValue;
19048 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
19050 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
19051 if(!isWasmInitialized) {
19052 throw new Error("initializeWasm() must be awaited first!");
19054 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
19055 return nativeResponseValue;
19057 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
19059 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
19060 if(!isWasmInitialized) {
19061 throw new Error("initializeWasm() must be awaited first!");
19063 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
19064 return nativeResponseValue;
19066 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
19068 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
19069 if(!isWasmInitialized) {
19070 throw new Error("initializeWasm() must be awaited first!");
19072 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
19073 return nativeResponseValue;
19075 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
19077 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
19078 if(!isWasmInitialized) {
19079 throw new Error("initializeWasm() must be awaited first!");
19081 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
19082 // debug statements here
19084 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
19086 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19087 if(!isWasmInitialized) {
19088 throw new Error("initializeWasm() must be awaited first!");
19090 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
19091 return nativeResponseValue;
19093 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
19095 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
19096 if(!isWasmInitialized) {
19097 throw new Error("initializeWasm() must be awaited first!");
19099 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
19100 return nativeResponseValue;
19102 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
19104 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
19105 if(!isWasmInitialized) {
19106 throw new Error("initializeWasm() must be awaited first!");
19108 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
19109 return nativeResponseValue;
19111 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
19113 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
19114 if(!isWasmInitialized) {
19115 throw new Error("initializeWasm() must be awaited first!");
19117 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
19118 return nativeResponseValue;
19120 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
19122 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
19123 if(!isWasmInitialized) {
19124 throw new Error("initializeWasm() must be awaited first!");
19126 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
19127 return nativeResponseValue;
19129 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
19131 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
19132 if(!isWasmInitialized) {
19133 throw new Error("initializeWasm() must be awaited first!");
19135 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
19136 // debug statements here
19138 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
19140 export function CResult_NoneErrorZ_ok(): bigint {
19141 if(!isWasmInitialized) {
19142 throw new Error("initializeWasm() must be awaited first!");
19144 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
19145 return nativeResponseValue;
19147 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
19149 export function CResult_NoneErrorZ_err(e: IOError): bigint {
19150 if(!isWasmInitialized) {
19151 throw new Error("initializeWasm() must be awaited first!");
19153 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
19154 return nativeResponseValue;
19156 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
19158 export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
19159 if(!isWasmInitialized) {
19160 throw new Error("initializeWasm() must be awaited first!");
19162 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
19163 return nativeResponseValue;
19165 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
19167 export function CResult_NoneErrorZ_free(_res: bigint): void {
19168 if(!isWasmInitialized) {
19169 throw new Error("initializeWasm() must be awaited first!");
19171 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
19172 // debug statements here
19174 // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
19176 export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
19177 if(!isWasmInitialized) {
19178 throw new Error("initializeWasm() must be awaited first!");
19180 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
19181 return nativeResponseValue;
19183 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
19185 export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
19186 if(!isWasmInitialized) {
19187 throw new Error("initializeWasm() must be awaited first!");
19189 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
19190 return nativeResponseValue;
19192 // struct LDKCOption_ScriptZ COption_ScriptZ_some(struct LDKCVec_u8Z o);
19194 export function COption_ScriptZ_some(o: number): bigint {
19195 if(!isWasmInitialized) {
19196 throw new Error("initializeWasm() must be awaited first!");
19198 const nativeResponseValue = wasm.TS_COption_ScriptZ_some(o);
19199 return nativeResponseValue;
19201 // struct LDKCOption_ScriptZ COption_ScriptZ_none(void);
19203 export function COption_ScriptZ_none(): bigint {
19204 if(!isWasmInitialized) {
19205 throw new Error("initializeWasm() must be awaited first!");
19207 const nativeResponseValue = wasm.TS_COption_ScriptZ_none();
19208 return nativeResponseValue;
19210 // void COption_ScriptZ_free(struct LDKCOption_ScriptZ _res);
19212 export function COption_ScriptZ_free(_res: bigint): void {
19213 if(!isWasmInitialized) {
19214 throw new Error("initializeWasm() must be awaited first!");
19216 const nativeResponseValue = wasm.TS_COption_ScriptZ_free(_res);
19217 // debug statements here
19219 // uint64_t COption_ScriptZ_clone_ptr(LDKCOption_ScriptZ *NONNULL_PTR arg);
19221 export function COption_ScriptZ_clone_ptr(arg: bigint): bigint {
19222 if(!isWasmInitialized) {
19223 throw new Error("initializeWasm() must be awaited first!");
19225 const nativeResponseValue = wasm.TS_COption_ScriptZ_clone_ptr(arg);
19226 return nativeResponseValue;
19228 // struct LDKCOption_ScriptZ COption_ScriptZ_clone(const struct LDKCOption_ScriptZ *NONNULL_PTR orig);
19230 export function COption_ScriptZ_clone(orig: bigint): bigint {
19231 if(!isWasmInitialized) {
19232 throw new Error("initializeWasm() must be awaited first!");
19234 const nativeResponseValue = wasm.TS_COption_ScriptZ_clone(orig);
19235 return nativeResponseValue;
19237 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
19239 export function COption_NoneZ_some(): COption_NoneZ {
19240 if(!isWasmInitialized) {
19241 throw new Error("initializeWasm() must be awaited first!");
19243 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
19244 return nativeResponseValue;
19246 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
19248 export function COption_NoneZ_none(): COption_NoneZ {
19249 if(!isWasmInitialized) {
19250 throw new Error("initializeWasm() must be awaited first!");
19252 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
19253 return nativeResponseValue;
19255 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
19257 export function COption_NoneZ_free(_res: COption_NoneZ): void {
19258 if(!isWasmInitialized) {
19259 throw new Error("initializeWasm() must be awaited first!");
19261 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
19262 // debug statements here
19264 // void CVec_WitnessZ_free(struct LDKCVec_WitnessZ _res);
19266 export function CVec_WitnessZ_free(_res: number): void {
19267 if(!isWasmInitialized) {
19268 throw new Error("initializeWasm() must be awaited first!");
19270 const nativeResponseValue = wasm.TS_CVec_WitnessZ_free(_res);
19271 // debug statements here
19273 // struct LDKCOption_i64Z COption_i64Z_some(int64_t o);
19275 export function COption_i64Z_some(o: bigint): bigint {
19276 if(!isWasmInitialized) {
19277 throw new Error("initializeWasm() must be awaited first!");
19279 const nativeResponseValue = wasm.TS_COption_i64Z_some(o);
19280 return nativeResponseValue;
19282 // struct LDKCOption_i64Z COption_i64Z_none(void);
19284 export function COption_i64Z_none(): bigint {
19285 if(!isWasmInitialized) {
19286 throw new Error("initializeWasm() must be awaited first!");
19288 const nativeResponseValue = wasm.TS_COption_i64Z_none();
19289 return nativeResponseValue;
19291 // void COption_i64Z_free(struct LDKCOption_i64Z _res);
19293 export function COption_i64Z_free(_res: bigint): void {
19294 if(!isWasmInitialized) {
19295 throw new Error("initializeWasm() must be awaited first!");
19297 const nativeResponseValue = wasm.TS_COption_i64Z_free(_res);
19298 // debug statements here
19300 // uint64_t COption_i64Z_clone_ptr(LDKCOption_i64Z *NONNULL_PTR arg);
19302 export function COption_i64Z_clone_ptr(arg: bigint): bigint {
19303 if(!isWasmInitialized) {
19304 throw new Error("initializeWasm() must be awaited first!");
19306 const nativeResponseValue = wasm.TS_COption_i64Z_clone_ptr(arg);
19307 return nativeResponseValue;
19309 // struct LDKCOption_i64Z COption_i64Z_clone(const struct LDKCOption_i64Z *NONNULL_PTR orig);
19311 export function COption_i64Z_clone(orig: bigint): bigint {
19312 if(!isWasmInitialized) {
19313 throw new Error("initializeWasm() must be awaited first!");
19315 const nativeResponseValue = wasm.TS_COption_i64Z_clone(orig);
19316 return nativeResponseValue;
19318 // struct LDKCOption_TxidZ COption_TxidZ_some(struct LDKThirtyTwoBytes o);
19320 export function COption_TxidZ_some(o: number): bigint {
19321 if(!isWasmInitialized) {
19322 throw new Error("initializeWasm() must be awaited first!");
19324 const nativeResponseValue = wasm.TS_COption_TxidZ_some(o);
19325 return nativeResponseValue;
19327 // struct LDKCOption_TxidZ COption_TxidZ_none(void);
19329 export function COption_TxidZ_none(): bigint {
19330 if(!isWasmInitialized) {
19331 throw new Error("initializeWasm() must be awaited first!");
19333 const nativeResponseValue = wasm.TS_COption_TxidZ_none();
19334 return nativeResponseValue;
19336 // void COption_TxidZ_free(struct LDKCOption_TxidZ _res);
19338 export function COption_TxidZ_free(_res: bigint): void {
19339 if(!isWasmInitialized) {
19340 throw new Error("initializeWasm() must be awaited first!");
19342 const nativeResponseValue = wasm.TS_COption_TxidZ_free(_res);
19343 // debug statements here
19345 // uint64_t COption_TxidZ_clone_ptr(LDKCOption_TxidZ *NONNULL_PTR arg);
19347 export function COption_TxidZ_clone_ptr(arg: bigint): bigint {
19348 if(!isWasmInitialized) {
19349 throw new Error("initializeWasm() must be awaited first!");
19351 const nativeResponseValue = wasm.TS_COption_TxidZ_clone_ptr(arg);
19352 return nativeResponseValue;
19354 // struct LDKCOption_TxidZ COption_TxidZ_clone(const struct LDKCOption_TxidZ *NONNULL_PTR orig);
19356 export function COption_TxidZ_clone(orig: bigint): bigint {
19357 if(!isWasmInitialized) {
19358 throw new Error("initializeWasm() must be awaited first!");
19360 const nativeResponseValue = wasm.TS_COption_TxidZ_clone(orig);
19361 return nativeResponseValue;
19363 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
19365 export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
19366 if(!isWasmInitialized) {
19367 throw new Error("initializeWasm() must be awaited first!");
19369 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
19370 return nativeResponseValue;
19372 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
19374 export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
19375 if(!isWasmInitialized) {
19376 throw new Error("initializeWasm() must be awaited first!");
19378 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
19379 return nativeResponseValue;
19381 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
19383 export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
19384 if(!isWasmInitialized) {
19385 throw new Error("initializeWasm() must be awaited first!");
19387 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
19388 return nativeResponseValue;
19390 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
19392 export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
19393 if(!isWasmInitialized) {
19394 throw new Error("initializeWasm() must be awaited first!");
19396 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
19397 // debug statements here
19399 // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
19401 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19402 if(!isWasmInitialized) {
19403 throw new Error("initializeWasm() must be awaited first!");
19405 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
19406 return nativeResponseValue;
19408 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
19410 export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
19411 if(!isWasmInitialized) {
19412 throw new Error("initializeWasm() must be awaited first!");
19414 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
19415 return nativeResponseValue;
19417 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
19419 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
19420 if(!isWasmInitialized) {
19421 throw new Error("initializeWasm() must be awaited first!");
19423 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
19424 // debug statements here
19426 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
19428 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
19429 if(!isWasmInitialized) {
19430 throw new Error("initializeWasm() must be awaited first!");
19432 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
19433 // debug statements here
19435 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
19437 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
19438 if(!isWasmInitialized) {
19439 throw new Error("initializeWasm() must be awaited first!");
19441 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
19442 // debug statements here
19444 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
19446 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
19447 if(!isWasmInitialized) {
19448 throw new Error("initializeWasm() must be awaited first!");
19450 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
19451 // debug statements here
19453 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
19455 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
19456 if(!isWasmInitialized) {
19457 throw new Error("initializeWasm() must be awaited first!");
19459 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
19460 return nativeResponseValue;
19462 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
19464 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
19465 if(!isWasmInitialized) {
19466 throw new Error("initializeWasm() must be awaited first!");
19468 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
19469 return nativeResponseValue;
19471 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
19473 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
19474 if(!isWasmInitialized) {
19475 throw new Error("initializeWasm() must be awaited first!");
19477 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
19478 return nativeResponseValue;
19480 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
19482 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
19483 if(!isWasmInitialized) {
19484 throw new Error("initializeWasm() must be awaited first!");
19486 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
19487 // debug statements here
19489 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
19491 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19492 if(!isWasmInitialized) {
19493 throw new Error("initializeWasm() must be awaited first!");
19495 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
19496 return nativeResponseValue;
19498 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
19500 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
19501 if(!isWasmInitialized) {
19502 throw new Error("initializeWasm() must be awaited first!");
19504 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
19505 return nativeResponseValue;
19507 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_ok(struct LDKAcceptChannelV2 o);
19509 export function CResult_AcceptChannelV2DecodeErrorZ_ok(o: bigint): bigint {
19510 if(!isWasmInitialized) {
19511 throw new Error("initializeWasm() must be awaited first!");
19513 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_ok(o);
19514 return nativeResponseValue;
19516 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
19518 export function CResult_AcceptChannelV2DecodeErrorZ_err(e: bigint): bigint {
19519 if(!isWasmInitialized) {
19520 throw new Error("initializeWasm() must be awaited first!");
19522 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_err(e);
19523 return nativeResponseValue;
19525 // bool CResult_AcceptChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR o);
19527 export function CResult_AcceptChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
19528 if(!isWasmInitialized) {
19529 throw new Error("initializeWasm() must be awaited first!");
19531 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok(o);
19532 return nativeResponseValue;
19534 // void CResult_AcceptChannelV2DecodeErrorZ_free(struct LDKCResult_AcceptChannelV2DecodeErrorZ _res);
19536 export function CResult_AcceptChannelV2DecodeErrorZ_free(_res: bigint): void {
19537 if(!isWasmInitialized) {
19538 throw new Error("initializeWasm() must be awaited first!");
19540 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_free(_res);
19541 // debug statements here
19543 // uint64_t CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR arg);
19545 export function CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
19546 if(!isWasmInitialized) {
19547 throw new Error("initializeWasm() must be awaited first!");
19549 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg);
19550 return nativeResponseValue;
19552 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_clone(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR orig);
19554 export function CResult_AcceptChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
19555 if(!isWasmInitialized) {
19556 throw new Error("initializeWasm() must be awaited first!");
19558 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone(orig);
19559 return nativeResponseValue;
19561 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_ok(struct LDKTxAddInput o);
19563 export function CResult_TxAddInputDecodeErrorZ_ok(o: bigint): bigint {
19564 if(!isWasmInitialized) {
19565 throw new Error("initializeWasm() must be awaited first!");
19567 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_ok(o);
19568 return nativeResponseValue;
19570 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_err(struct LDKDecodeError e);
19572 export function CResult_TxAddInputDecodeErrorZ_err(e: bigint): bigint {
19573 if(!isWasmInitialized) {
19574 throw new Error("initializeWasm() must be awaited first!");
19576 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_err(e);
19577 return nativeResponseValue;
19579 // bool CResult_TxAddInputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR o);
19581 export function CResult_TxAddInputDecodeErrorZ_is_ok(o: bigint): boolean {
19582 if(!isWasmInitialized) {
19583 throw new Error("initializeWasm() must be awaited first!");
19585 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_is_ok(o);
19586 return nativeResponseValue;
19588 // void CResult_TxAddInputDecodeErrorZ_free(struct LDKCResult_TxAddInputDecodeErrorZ _res);
19590 export function CResult_TxAddInputDecodeErrorZ_free(_res: bigint): void {
19591 if(!isWasmInitialized) {
19592 throw new Error("initializeWasm() must be awaited first!");
19594 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_free(_res);
19595 // debug statements here
19597 // uint64_t CResult_TxAddInputDecodeErrorZ_clone_ptr(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR arg);
19599 export function CResult_TxAddInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19600 if(!isWasmInitialized) {
19601 throw new Error("initializeWasm() must be awaited first!");
19603 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone_ptr(arg);
19604 return nativeResponseValue;
19606 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_clone(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR orig);
19608 export function CResult_TxAddInputDecodeErrorZ_clone(orig: bigint): bigint {
19609 if(!isWasmInitialized) {
19610 throw new Error("initializeWasm() must be awaited first!");
19612 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone(orig);
19613 return nativeResponseValue;
19615 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_ok(struct LDKTxAddOutput o);
19617 export function CResult_TxAddOutputDecodeErrorZ_ok(o: bigint): bigint {
19618 if(!isWasmInitialized) {
19619 throw new Error("initializeWasm() must be awaited first!");
19621 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_ok(o);
19622 return nativeResponseValue;
19624 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_err(struct LDKDecodeError e);
19626 export function CResult_TxAddOutputDecodeErrorZ_err(e: bigint): bigint {
19627 if(!isWasmInitialized) {
19628 throw new Error("initializeWasm() must be awaited first!");
19630 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_err(e);
19631 return nativeResponseValue;
19633 // bool CResult_TxAddOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR o);
19635 export function CResult_TxAddOutputDecodeErrorZ_is_ok(o: bigint): boolean {
19636 if(!isWasmInitialized) {
19637 throw new Error("initializeWasm() must be awaited first!");
19639 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_is_ok(o);
19640 return nativeResponseValue;
19642 // void CResult_TxAddOutputDecodeErrorZ_free(struct LDKCResult_TxAddOutputDecodeErrorZ _res);
19644 export function CResult_TxAddOutputDecodeErrorZ_free(_res: bigint): void {
19645 if(!isWasmInitialized) {
19646 throw new Error("initializeWasm() must be awaited first!");
19648 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_free(_res);
19649 // debug statements here
19651 // uint64_t CResult_TxAddOutputDecodeErrorZ_clone_ptr(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR arg);
19653 export function CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19654 if(!isWasmInitialized) {
19655 throw new Error("initializeWasm() must be awaited first!");
19657 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg);
19658 return nativeResponseValue;
19660 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_clone(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR orig);
19662 export function CResult_TxAddOutputDecodeErrorZ_clone(orig: bigint): bigint {
19663 if(!isWasmInitialized) {
19664 throw new Error("initializeWasm() must be awaited first!");
19666 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone(orig);
19667 return nativeResponseValue;
19669 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_ok(struct LDKTxRemoveInput o);
19671 export function CResult_TxRemoveInputDecodeErrorZ_ok(o: bigint): bigint {
19672 if(!isWasmInitialized) {
19673 throw new Error("initializeWasm() must be awaited first!");
19675 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_ok(o);
19676 return nativeResponseValue;
19678 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_err(struct LDKDecodeError e);
19680 export function CResult_TxRemoveInputDecodeErrorZ_err(e: bigint): bigint {
19681 if(!isWasmInitialized) {
19682 throw new Error("initializeWasm() must be awaited first!");
19684 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_err(e);
19685 return nativeResponseValue;
19687 // bool CResult_TxRemoveInputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR o);
19689 export function CResult_TxRemoveInputDecodeErrorZ_is_ok(o: bigint): boolean {
19690 if(!isWasmInitialized) {
19691 throw new Error("initializeWasm() must be awaited first!");
19693 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_is_ok(o);
19694 return nativeResponseValue;
19696 // void CResult_TxRemoveInputDecodeErrorZ_free(struct LDKCResult_TxRemoveInputDecodeErrorZ _res);
19698 export function CResult_TxRemoveInputDecodeErrorZ_free(_res: bigint): void {
19699 if(!isWasmInitialized) {
19700 throw new Error("initializeWasm() must be awaited first!");
19702 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_free(_res);
19703 // debug statements here
19705 // uint64_t CResult_TxRemoveInputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR arg);
19707 export function CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19708 if(!isWasmInitialized) {
19709 throw new Error("initializeWasm() must be awaited first!");
19711 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg);
19712 return nativeResponseValue;
19714 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR orig);
19716 export function CResult_TxRemoveInputDecodeErrorZ_clone(orig: bigint): bigint {
19717 if(!isWasmInitialized) {
19718 throw new Error("initializeWasm() must be awaited first!");
19720 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone(orig);
19721 return nativeResponseValue;
19723 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_ok(struct LDKTxRemoveOutput o);
19725 export function CResult_TxRemoveOutputDecodeErrorZ_ok(o: bigint): bigint {
19726 if(!isWasmInitialized) {
19727 throw new Error("initializeWasm() must be awaited first!");
19729 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_ok(o);
19730 return nativeResponseValue;
19732 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_err(struct LDKDecodeError e);
19734 export function CResult_TxRemoveOutputDecodeErrorZ_err(e: bigint): bigint {
19735 if(!isWasmInitialized) {
19736 throw new Error("initializeWasm() must be awaited first!");
19738 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_err(e);
19739 return nativeResponseValue;
19741 // bool CResult_TxRemoveOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR o);
19743 export function CResult_TxRemoveOutputDecodeErrorZ_is_ok(o: bigint): boolean {
19744 if(!isWasmInitialized) {
19745 throw new Error("initializeWasm() must be awaited first!");
19747 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok(o);
19748 return nativeResponseValue;
19750 // void CResult_TxRemoveOutputDecodeErrorZ_free(struct LDKCResult_TxRemoveOutputDecodeErrorZ _res);
19752 export function CResult_TxRemoveOutputDecodeErrorZ_free(_res: bigint): void {
19753 if(!isWasmInitialized) {
19754 throw new Error("initializeWasm() must be awaited first!");
19756 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_free(_res);
19757 // debug statements here
19759 // uint64_t CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR arg);
19761 export function CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19762 if(!isWasmInitialized) {
19763 throw new Error("initializeWasm() must be awaited first!");
19765 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg);
19766 return nativeResponseValue;
19768 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR orig);
19770 export function CResult_TxRemoveOutputDecodeErrorZ_clone(orig: bigint): bigint {
19771 if(!isWasmInitialized) {
19772 throw new Error("initializeWasm() must be awaited first!");
19774 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone(orig);
19775 return nativeResponseValue;
19777 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_ok(struct LDKTxComplete o);
19779 export function CResult_TxCompleteDecodeErrorZ_ok(o: bigint): bigint {
19780 if(!isWasmInitialized) {
19781 throw new Error("initializeWasm() must be awaited first!");
19783 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_ok(o);
19784 return nativeResponseValue;
19786 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_err(struct LDKDecodeError e);
19788 export function CResult_TxCompleteDecodeErrorZ_err(e: bigint): bigint {
19789 if(!isWasmInitialized) {
19790 throw new Error("initializeWasm() must be awaited first!");
19792 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_err(e);
19793 return nativeResponseValue;
19795 // bool CResult_TxCompleteDecodeErrorZ_is_ok(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR o);
19797 export function CResult_TxCompleteDecodeErrorZ_is_ok(o: bigint): boolean {
19798 if(!isWasmInitialized) {
19799 throw new Error("initializeWasm() must be awaited first!");
19801 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_is_ok(o);
19802 return nativeResponseValue;
19804 // void CResult_TxCompleteDecodeErrorZ_free(struct LDKCResult_TxCompleteDecodeErrorZ _res);
19806 export function CResult_TxCompleteDecodeErrorZ_free(_res: bigint): void {
19807 if(!isWasmInitialized) {
19808 throw new Error("initializeWasm() must be awaited first!");
19810 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_free(_res);
19811 // debug statements here
19813 // uint64_t CResult_TxCompleteDecodeErrorZ_clone_ptr(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR arg);
19815 export function CResult_TxCompleteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19816 if(!isWasmInitialized) {
19817 throw new Error("initializeWasm() must be awaited first!");
19819 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone_ptr(arg);
19820 return nativeResponseValue;
19822 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_clone(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR orig);
19824 export function CResult_TxCompleteDecodeErrorZ_clone(orig: bigint): bigint {
19825 if(!isWasmInitialized) {
19826 throw new Error("initializeWasm() must be awaited first!");
19828 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone(orig);
19829 return nativeResponseValue;
19831 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_ok(struct LDKTxSignatures o);
19833 export function CResult_TxSignaturesDecodeErrorZ_ok(o: bigint): bigint {
19834 if(!isWasmInitialized) {
19835 throw new Error("initializeWasm() must be awaited first!");
19837 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_ok(o);
19838 return nativeResponseValue;
19840 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
19842 export function CResult_TxSignaturesDecodeErrorZ_err(e: bigint): bigint {
19843 if(!isWasmInitialized) {
19844 throw new Error("initializeWasm() must be awaited first!");
19846 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_err(e);
19847 return nativeResponseValue;
19849 // bool CResult_TxSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR o);
19851 export function CResult_TxSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
19852 if(!isWasmInitialized) {
19853 throw new Error("initializeWasm() must be awaited first!");
19855 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_is_ok(o);
19856 return nativeResponseValue;
19858 // void CResult_TxSignaturesDecodeErrorZ_free(struct LDKCResult_TxSignaturesDecodeErrorZ _res);
19860 export function CResult_TxSignaturesDecodeErrorZ_free(_res: bigint): void {
19861 if(!isWasmInitialized) {
19862 throw new Error("initializeWasm() must be awaited first!");
19864 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_free(_res);
19865 // debug statements here
19867 // uint64_t CResult_TxSignaturesDecodeErrorZ_clone_ptr(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR arg);
19869 export function CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19870 if(!isWasmInitialized) {
19871 throw new Error("initializeWasm() must be awaited first!");
19873 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg);
19874 return nativeResponseValue;
19876 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_clone(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR orig);
19878 export function CResult_TxSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
19879 if(!isWasmInitialized) {
19880 throw new Error("initializeWasm() must be awaited first!");
19882 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone(orig);
19883 return nativeResponseValue;
19885 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_ok(struct LDKTxInitRbf o);
19887 export function CResult_TxInitRbfDecodeErrorZ_ok(o: bigint): bigint {
19888 if(!isWasmInitialized) {
19889 throw new Error("initializeWasm() must be awaited first!");
19891 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_ok(o);
19892 return nativeResponseValue;
19894 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_err(struct LDKDecodeError e);
19896 export function CResult_TxInitRbfDecodeErrorZ_err(e: bigint): bigint {
19897 if(!isWasmInitialized) {
19898 throw new Error("initializeWasm() must be awaited first!");
19900 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_err(e);
19901 return nativeResponseValue;
19903 // bool CResult_TxInitRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR o);
19905 export function CResult_TxInitRbfDecodeErrorZ_is_ok(o: bigint): boolean {
19906 if(!isWasmInitialized) {
19907 throw new Error("initializeWasm() must be awaited first!");
19909 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_is_ok(o);
19910 return nativeResponseValue;
19912 // void CResult_TxInitRbfDecodeErrorZ_free(struct LDKCResult_TxInitRbfDecodeErrorZ _res);
19914 export function CResult_TxInitRbfDecodeErrorZ_free(_res: bigint): void {
19915 if(!isWasmInitialized) {
19916 throw new Error("initializeWasm() must be awaited first!");
19918 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_free(_res);
19919 // debug statements here
19921 // uint64_t CResult_TxInitRbfDecodeErrorZ_clone_ptr(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR arg);
19923 export function CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19924 if(!isWasmInitialized) {
19925 throw new Error("initializeWasm() must be awaited first!");
19927 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg);
19928 return nativeResponseValue;
19930 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_clone(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR orig);
19932 export function CResult_TxInitRbfDecodeErrorZ_clone(orig: bigint): bigint {
19933 if(!isWasmInitialized) {
19934 throw new Error("initializeWasm() must be awaited first!");
19936 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone(orig);
19937 return nativeResponseValue;
19939 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_ok(struct LDKTxAckRbf o);
19941 export function CResult_TxAckRbfDecodeErrorZ_ok(o: bigint): bigint {
19942 if(!isWasmInitialized) {
19943 throw new Error("initializeWasm() must be awaited first!");
19945 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_ok(o);
19946 return nativeResponseValue;
19948 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_err(struct LDKDecodeError e);
19950 export function CResult_TxAckRbfDecodeErrorZ_err(e: bigint): bigint {
19951 if(!isWasmInitialized) {
19952 throw new Error("initializeWasm() must be awaited first!");
19954 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_err(e);
19955 return nativeResponseValue;
19957 // bool CResult_TxAckRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR o);
19959 export function CResult_TxAckRbfDecodeErrorZ_is_ok(o: bigint): boolean {
19960 if(!isWasmInitialized) {
19961 throw new Error("initializeWasm() must be awaited first!");
19963 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_is_ok(o);
19964 return nativeResponseValue;
19966 // void CResult_TxAckRbfDecodeErrorZ_free(struct LDKCResult_TxAckRbfDecodeErrorZ _res);
19968 export function CResult_TxAckRbfDecodeErrorZ_free(_res: bigint): void {
19969 if(!isWasmInitialized) {
19970 throw new Error("initializeWasm() must be awaited first!");
19972 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_free(_res);
19973 // debug statements here
19975 // uint64_t CResult_TxAckRbfDecodeErrorZ_clone_ptr(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR arg);
19977 export function CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19978 if(!isWasmInitialized) {
19979 throw new Error("initializeWasm() must be awaited first!");
19981 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg);
19982 return nativeResponseValue;
19984 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_clone(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR orig);
19986 export function CResult_TxAckRbfDecodeErrorZ_clone(orig: bigint): bigint {
19987 if(!isWasmInitialized) {
19988 throw new Error("initializeWasm() must be awaited first!");
19990 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone(orig);
19991 return nativeResponseValue;
19993 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_ok(struct LDKTxAbort o);
19995 export function CResult_TxAbortDecodeErrorZ_ok(o: bigint): bigint {
19996 if(!isWasmInitialized) {
19997 throw new Error("initializeWasm() must be awaited first!");
19999 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_ok(o);
20000 return nativeResponseValue;
20002 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_err(struct LDKDecodeError e);
20004 export function CResult_TxAbortDecodeErrorZ_err(e: bigint): bigint {
20005 if(!isWasmInitialized) {
20006 throw new Error("initializeWasm() must be awaited first!");
20008 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_err(e);
20009 return nativeResponseValue;
20011 // bool CResult_TxAbortDecodeErrorZ_is_ok(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR o);
20013 export function CResult_TxAbortDecodeErrorZ_is_ok(o: bigint): boolean {
20014 if(!isWasmInitialized) {
20015 throw new Error("initializeWasm() must be awaited first!");
20017 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_is_ok(o);
20018 return nativeResponseValue;
20020 // void CResult_TxAbortDecodeErrorZ_free(struct LDKCResult_TxAbortDecodeErrorZ _res);
20022 export function CResult_TxAbortDecodeErrorZ_free(_res: bigint): void {
20023 if(!isWasmInitialized) {
20024 throw new Error("initializeWasm() must be awaited first!");
20026 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_free(_res);
20027 // debug statements here
20029 // uint64_t CResult_TxAbortDecodeErrorZ_clone_ptr(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR arg);
20031 export function CResult_TxAbortDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20032 if(!isWasmInitialized) {
20033 throw new Error("initializeWasm() must be awaited first!");
20035 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone_ptr(arg);
20036 return nativeResponseValue;
20038 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_clone(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR orig);
20040 export function CResult_TxAbortDecodeErrorZ_clone(orig: bigint): bigint {
20041 if(!isWasmInitialized) {
20042 throw new Error("initializeWasm() must be awaited first!");
20044 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone(orig);
20045 return nativeResponseValue;
20047 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
20049 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
20050 if(!isWasmInitialized) {
20051 throw new Error("initializeWasm() must be awaited first!");
20053 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
20054 return nativeResponseValue;
20056 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
20058 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
20059 if(!isWasmInitialized) {
20060 throw new Error("initializeWasm() must be awaited first!");
20062 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
20063 return nativeResponseValue;
20065 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
20067 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
20068 if(!isWasmInitialized) {
20069 throw new Error("initializeWasm() must be awaited first!");
20071 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
20072 return nativeResponseValue;
20074 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
20076 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
20077 if(!isWasmInitialized) {
20078 throw new Error("initializeWasm() must be awaited first!");
20080 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
20081 // debug statements here
20083 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
20085 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20086 if(!isWasmInitialized) {
20087 throw new Error("initializeWasm() must be awaited first!");
20089 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
20090 return nativeResponseValue;
20092 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
20094 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
20095 if(!isWasmInitialized) {
20096 throw new Error("initializeWasm() must be awaited first!");
20098 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
20099 return nativeResponseValue;
20101 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
20103 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
20104 if(!isWasmInitialized) {
20105 throw new Error("initializeWasm() must be awaited first!");
20107 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
20108 return nativeResponseValue;
20110 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
20112 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
20113 if(!isWasmInitialized) {
20114 throw new Error("initializeWasm() must be awaited first!");
20116 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
20117 return nativeResponseValue;
20119 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
20121 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
20122 if(!isWasmInitialized) {
20123 throw new Error("initializeWasm() must be awaited first!");
20125 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
20126 return nativeResponseValue;
20128 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
20130 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
20131 if(!isWasmInitialized) {
20132 throw new Error("initializeWasm() must be awaited first!");
20134 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
20135 // debug statements here
20137 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
20139 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20140 if(!isWasmInitialized) {
20141 throw new Error("initializeWasm() must be awaited first!");
20143 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
20144 return nativeResponseValue;
20146 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
20148 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
20149 if(!isWasmInitialized) {
20150 throw new Error("initializeWasm() must be awaited first!");
20152 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
20153 return nativeResponseValue;
20155 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
20157 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
20158 if(!isWasmInitialized) {
20159 throw new Error("initializeWasm() must be awaited first!");
20161 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
20162 return nativeResponseValue;
20164 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
20166 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
20167 if(!isWasmInitialized) {
20168 throw new Error("initializeWasm() must be awaited first!");
20170 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
20171 return nativeResponseValue;
20173 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
20175 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
20176 if(!isWasmInitialized) {
20177 throw new Error("initializeWasm() must be awaited first!");
20179 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
20180 return nativeResponseValue;
20182 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
20184 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
20185 if(!isWasmInitialized) {
20186 throw new Error("initializeWasm() must be awaited first!");
20188 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
20189 // debug statements here
20191 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
20193 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20194 if(!isWasmInitialized) {
20195 throw new Error("initializeWasm() must be awaited first!");
20197 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
20198 return nativeResponseValue;
20200 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
20202 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
20203 if(!isWasmInitialized) {
20204 throw new Error("initializeWasm() must be awaited first!");
20206 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
20207 return nativeResponseValue;
20209 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
20211 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
20212 if(!isWasmInitialized) {
20213 throw new Error("initializeWasm() must be awaited first!");
20215 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
20216 return nativeResponseValue;
20218 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
20220 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
20221 if(!isWasmInitialized) {
20222 throw new Error("initializeWasm() must be awaited first!");
20224 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
20225 return nativeResponseValue;
20227 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
20229 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
20230 if(!isWasmInitialized) {
20231 throw new Error("initializeWasm() must be awaited first!");
20233 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
20234 return nativeResponseValue;
20236 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
20238 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
20239 if(!isWasmInitialized) {
20240 throw new Error("initializeWasm() must be awaited first!");
20242 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
20243 // debug statements here
20245 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
20247 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20248 if(!isWasmInitialized) {
20249 throw new Error("initializeWasm() must be awaited first!");
20251 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
20252 return nativeResponseValue;
20254 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
20256 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
20257 if(!isWasmInitialized) {
20258 throw new Error("initializeWasm() must be awaited first!");
20260 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
20261 return nativeResponseValue;
20263 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
20265 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
20266 if(!isWasmInitialized) {
20267 throw new Error("initializeWasm() must be awaited first!");
20269 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
20270 return nativeResponseValue;
20272 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
20274 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
20275 if(!isWasmInitialized) {
20276 throw new Error("initializeWasm() must be awaited first!");
20278 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
20279 return nativeResponseValue;
20281 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
20283 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
20284 if(!isWasmInitialized) {
20285 throw new Error("initializeWasm() must be awaited first!");
20287 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
20288 return nativeResponseValue;
20290 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
20292 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
20293 if(!isWasmInitialized) {
20294 throw new Error("initializeWasm() must be awaited first!");
20296 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
20297 // debug statements here
20299 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
20301 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20302 if(!isWasmInitialized) {
20303 throw new Error("initializeWasm() must be awaited first!");
20305 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
20306 return nativeResponseValue;
20308 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
20310 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
20311 if(!isWasmInitialized) {
20312 throw new Error("initializeWasm() must be awaited first!");
20314 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
20315 return nativeResponseValue;
20317 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
20319 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
20320 if(!isWasmInitialized) {
20321 throw new Error("initializeWasm() must be awaited first!");
20323 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
20324 return nativeResponseValue;
20326 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
20328 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
20329 if(!isWasmInitialized) {
20330 throw new Error("initializeWasm() must be awaited first!");
20332 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
20333 return nativeResponseValue;
20335 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
20337 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
20338 if(!isWasmInitialized) {
20339 throw new Error("initializeWasm() must be awaited first!");
20341 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
20342 return nativeResponseValue;
20344 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
20346 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
20347 if(!isWasmInitialized) {
20348 throw new Error("initializeWasm() must be awaited first!");
20350 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
20351 // debug statements here
20353 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
20355 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20356 if(!isWasmInitialized) {
20357 throw new Error("initializeWasm() must be awaited first!");
20359 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
20360 return nativeResponseValue;
20362 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
20364 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
20365 if(!isWasmInitialized) {
20366 throw new Error("initializeWasm() must be awaited first!");
20368 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
20369 return nativeResponseValue;
20371 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
20373 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
20374 if(!isWasmInitialized) {
20375 throw new Error("initializeWasm() must be awaited first!");
20377 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
20378 return nativeResponseValue;
20380 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
20382 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
20383 if(!isWasmInitialized) {
20384 throw new Error("initializeWasm() must be awaited first!");
20386 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
20387 return nativeResponseValue;
20389 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
20391 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
20392 if(!isWasmInitialized) {
20393 throw new Error("initializeWasm() must be awaited first!");
20395 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
20396 return nativeResponseValue;
20398 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
20400 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
20401 if(!isWasmInitialized) {
20402 throw new Error("initializeWasm() must be awaited first!");
20404 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
20405 // debug statements here
20407 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
20409 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20410 if(!isWasmInitialized) {
20411 throw new Error("initializeWasm() must be awaited first!");
20413 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
20414 return nativeResponseValue;
20416 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
20418 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
20419 if(!isWasmInitialized) {
20420 throw new Error("initializeWasm() must be awaited first!");
20422 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
20423 return nativeResponseValue;
20425 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
20427 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
20428 if(!isWasmInitialized) {
20429 throw new Error("initializeWasm() must be awaited first!");
20431 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
20432 return nativeResponseValue;
20434 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
20436 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
20437 if(!isWasmInitialized) {
20438 throw new Error("initializeWasm() must be awaited first!");
20440 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
20441 return nativeResponseValue;
20443 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
20445 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
20446 if(!isWasmInitialized) {
20447 throw new Error("initializeWasm() must be awaited first!");
20449 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
20450 return nativeResponseValue;
20452 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
20454 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
20455 if(!isWasmInitialized) {
20456 throw new Error("initializeWasm() must be awaited first!");
20458 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
20459 // debug statements here
20461 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
20463 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20464 if(!isWasmInitialized) {
20465 throw new Error("initializeWasm() must be awaited first!");
20467 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
20468 return nativeResponseValue;
20470 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
20472 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
20473 if(!isWasmInitialized) {
20474 throw new Error("initializeWasm() must be awaited first!");
20476 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
20477 return nativeResponseValue;
20479 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
20481 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
20482 if(!isWasmInitialized) {
20483 throw new Error("initializeWasm() must be awaited first!");
20485 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
20486 return nativeResponseValue;
20488 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
20490 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
20491 if(!isWasmInitialized) {
20492 throw new Error("initializeWasm() must be awaited first!");
20494 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
20495 return nativeResponseValue;
20497 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
20499 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
20500 if(!isWasmInitialized) {
20501 throw new Error("initializeWasm() must be awaited first!");
20503 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
20504 return nativeResponseValue;
20506 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
20508 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
20509 if(!isWasmInitialized) {
20510 throw new Error("initializeWasm() must be awaited first!");
20512 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
20513 // debug statements here
20515 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
20517 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20518 if(!isWasmInitialized) {
20519 throw new Error("initializeWasm() must be awaited first!");
20521 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
20522 return nativeResponseValue;
20524 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
20526 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
20527 if(!isWasmInitialized) {
20528 throw new Error("initializeWasm() must be awaited first!");
20530 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
20531 return nativeResponseValue;
20533 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
20535 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
20536 if(!isWasmInitialized) {
20537 throw new Error("initializeWasm() must be awaited first!");
20539 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
20540 return nativeResponseValue;
20542 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
20544 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
20545 if(!isWasmInitialized) {
20546 throw new Error("initializeWasm() must be awaited first!");
20548 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
20549 return nativeResponseValue;
20551 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
20553 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
20554 if(!isWasmInitialized) {
20555 throw new Error("initializeWasm() must be awaited first!");
20557 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
20558 return nativeResponseValue;
20560 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
20562 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
20563 if(!isWasmInitialized) {
20564 throw new Error("initializeWasm() must be awaited first!");
20566 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
20567 // debug statements here
20569 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
20571 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20572 if(!isWasmInitialized) {
20573 throw new Error("initializeWasm() must be awaited first!");
20575 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
20576 return nativeResponseValue;
20578 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
20580 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
20581 if(!isWasmInitialized) {
20582 throw new Error("initializeWasm() must be awaited first!");
20584 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
20585 return nativeResponseValue;
20587 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_ok(struct LDKOpenChannelV2 o);
20589 export function CResult_OpenChannelV2DecodeErrorZ_ok(o: bigint): bigint {
20590 if(!isWasmInitialized) {
20591 throw new Error("initializeWasm() must be awaited first!");
20593 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_ok(o);
20594 return nativeResponseValue;
20596 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
20598 export function CResult_OpenChannelV2DecodeErrorZ_err(e: bigint): bigint {
20599 if(!isWasmInitialized) {
20600 throw new Error("initializeWasm() must be awaited first!");
20602 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_err(e);
20603 return nativeResponseValue;
20605 // bool CResult_OpenChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR o);
20607 export function CResult_OpenChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
20608 if(!isWasmInitialized) {
20609 throw new Error("initializeWasm() must be awaited first!");
20611 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_is_ok(o);
20612 return nativeResponseValue;
20614 // void CResult_OpenChannelV2DecodeErrorZ_free(struct LDKCResult_OpenChannelV2DecodeErrorZ _res);
20616 export function CResult_OpenChannelV2DecodeErrorZ_free(_res: bigint): void {
20617 if(!isWasmInitialized) {
20618 throw new Error("initializeWasm() must be awaited first!");
20620 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_free(_res);
20621 // debug statements here
20623 // uint64_t CResult_OpenChannelV2DecodeErrorZ_clone_ptr(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR arg);
20625 export function CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
20626 if(!isWasmInitialized) {
20627 throw new Error("initializeWasm() must be awaited first!");
20629 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg);
20630 return nativeResponseValue;
20632 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_clone(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR orig);
20634 export function CResult_OpenChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
20635 if(!isWasmInitialized) {
20636 throw new Error("initializeWasm() must be awaited first!");
20638 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone(orig);
20639 return nativeResponseValue;
20641 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
20643 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
20644 if(!isWasmInitialized) {
20645 throw new Error("initializeWasm() must be awaited first!");
20647 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
20648 return nativeResponseValue;
20650 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
20652 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
20653 if(!isWasmInitialized) {
20654 throw new Error("initializeWasm() must be awaited first!");
20656 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
20657 return nativeResponseValue;
20659 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
20661 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
20662 if(!isWasmInitialized) {
20663 throw new Error("initializeWasm() must be awaited first!");
20665 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
20666 return nativeResponseValue;
20668 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
20670 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
20671 if(!isWasmInitialized) {
20672 throw new Error("initializeWasm() must be awaited first!");
20674 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
20675 // debug statements here
20677 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
20679 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20680 if(!isWasmInitialized) {
20681 throw new Error("initializeWasm() must be awaited first!");
20683 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
20684 return nativeResponseValue;
20686 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
20688 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
20689 if(!isWasmInitialized) {
20690 throw new Error("initializeWasm() must be awaited first!");
20692 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
20693 return nativeResponseValue;
20695 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
20697 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
20698 if(!isWasmInitialized) {
20699 throw new Error("initializeWasm() must be awaited first!");
20701 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
20702 return nativeResponseValue;
20704 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
20706 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
20707 if(!isWasmInitialized) {
20708 throw new Error("initializeWasm() must be awaited first!");
20710 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
20711 return nativeResponseValue;
20713 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
20715 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
20716 if(!isWasmInitialized) {
20717 throw new Error("initializeWasm() must be awaited first!");
20719 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
20720 return nativeResponseValue;
20722 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
20724 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
20725 if(!isWasmInitialized) {
20726 throw new Error("initializeWasm() must be awaited first!");
20728 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
20729 // debug statements here
20731 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
20733 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20734 if(!isWasmInitialized) {
20735 throw new Error("initializeWasm() must be awaited first!");
20737 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
20738 return nativeResponseValue;
20740 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
20742 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
20743 if(!isWasmInitialized) {
20744 throw new Error("initializeWasm() must be awaited first!");
20746 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
20747 return nativeResponseValue;
20749 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
20751 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
20752 if(!isWasmInitialized) {
20753 throw new Error("initializeWasm() must be awaited first!");
20755 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
20756 return nativeResponseValue;
20758 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
20760 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
20761 if(!isWasmInitialized) {
20762 throw new Error("initializeWasm() must be awaited first!");
20764 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
20765 return nativeResponseValue;
20767 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
20769 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
20770 if(!isWasmInitialized) {
20771 throw new Error("initializeWasm() must be awaited first!");
20773 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
20774 return nativeResponseValue;
20776 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
20778 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
20779 if(!isWasmInitialized) {
20780 throw new Error("initializeWasm() must be awaited first!");
20782 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
20783 // debug statements here
20785 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
20787 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20788 if(!isWasmInitialized) {
20789 throw new Error("initializeWasm() must be awaited first!");
20791 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
20792 return nativeResponseValue;
20794 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
20796 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
20797 if(!isWasmInitialized) {
20798 throw new Error("initializeWasm() must be awaited first!");
20800 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
20801 return nativeResponseValue;
20803 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
20805 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
20806 if(!isWasmInitialized) {
20807 throw new Error("initializeWasm() must be awaited first!");
20809 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
20810 return nativeResponseValue;
20812 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
20814 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
20815 if(!isWasmInitialized) {
20816 throw new Error("initializeWasm() must be awaited first!");
20818 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
20819 return nativeResponseValue;
20821 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
20823 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
20824 if(!isWasmInitialized) {
20825 throw new Error("initializeWasm() must be awaited first!");
20827 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
20828 return nativeResponseValue;
20830 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
20832 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
20833 if(!isWasmInitialized) {
20834 throw new Error("initializeWasm() must be awaited first!");
20836 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
20837 // debug statements here
20839 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
20841 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20842 if(!isWasmInitialized) {
20843 throw new Error("initializeWasm() must be awaited first!");
20845 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
20846 return nativeResponseValue;
20848 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
20850 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
20851 if(!isWasmInitialized) {
20852 throw new Error("initializeWasm() must be awaited first!");
20854 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
20855 return nativeResponseValue;
20857 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
20859 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
20860 if(!isWasmInitialized) {
20861 throw new Error("initializeWasm() must be awaited first!");
20863 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
20864 return nativeResponseValue;
20866 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
20868 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
20869 if(!isWasmInitialized) {
20870 throw new Error("initializeWasm() must be awaited first!");
20872 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
20873 return nativeResponseValue;
20875 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
20877 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
20878 if(!isWasmInitialized) {
20879 throw new Error("initializeWasm() must be awaited first!");
20881 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
20882 return nativeResponseValue;
20884 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
20886 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
20887 if(!isWasmInitialized) {
20888 throw new Error("initializeWasm() must be awaited first!");
20890 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
20891 // debug statements here
20893 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
20895 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20896 if(!isWasmInitialized) {
20897 throw new Error("initializeWasm() must be awaited first!");
20899 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
20900 return nativeResponseValue;
20902 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
20904 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
20905 if(!isWasmInitialized) {
20906 throw new Error("initializeWasm() must be awaited first!");
20908 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
20909 return nativeResponseValue;
20911 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
20913 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
20914 if(!isWasmInitialized) {
20915 throw new Error("initializeWasm() must be awaited first!");
20917 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
20918 return nativeResponseValue;
20920 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
20922 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
20923 if(!isWasmInitialized) {
20924 throw new Error("initializeWasm() must be awaited first!");
20926 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
20927 return nativeResponseValue;
20929 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
20931 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
20932 if(!isWasmInitialized) {
20933 throw new Error("initializeWasm() must be awaited first!");
20935 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
20936 return nativeResponseValue;
20938 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
20940 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
20941 if(!isWasmInitialized) {
20942 throw new Error("initializeWasm() must be awaited first!");
20944 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
20945 // debug statements here
20947 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
20949 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20950 if(!isWasmInitialized) {
20951 throw new Error("initializeWasm() must be awaited first!");
20953 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
20954 return nativeResponseValue;
20956 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
20958 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
20959 if(!isWasmInitialized) {
20960 throw new Error("initializeWasm() must be awaited first!");
20962 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
20963 return nativeResponseValue;
20965 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
20967 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
20968 if(!isWasmInitialized) {
20969 throw new Error("initializeWasm() must be awaited first!");
20971 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
20972 return nativeResponseValue;
20974 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
20976 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
20977 if(!isWasmInitialized) {
20978 throw new Error("initializeWasm() must be awaited first!");
20980 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
20981 return nativeResponseValue;
20983 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
20985 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
20986 if(!isWasmInitialized) {
20987 throw new Error("initializeWasm() must be awaited first!");
20989 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
20990 return nativeResponseValue;
20992 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
20994 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
20995 if(!isWasmInitialized) {
20996 throw new Error("initializeWasm() must be awaited first!");
20998 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
20999 // debug statements here
21001 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
21003 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21004 if(!isWasmInitialized) {
21005 throw new Error("initializeWasm() must be awaited first!");
21007 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
21008 return nativeResponseValue;
21010 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
21012 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
21013 if(!isWasmInitialized) {
21014 throw new Error("initializeWasm() must be awaited first!");
21016 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
21017 return nativeResponseValue;
21019 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
21021 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
21022 if(!isWasmInitialized) {
21023 throw new Error("initializeWasm() must be awaited first!");
21025 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
21026 return nativeResponseValue;
21028 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
21030 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
21031 if(!isWasmInitialized) {
21032 throw new Error("initializeWasm() must be awaited first!");
21034 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
21035 return nativeResponseValue;
21037 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
21039 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
21040 if(!isWasmInitialized) {
21041 throw new Error("initializeWasm() must be awaited first!");
21043 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
21044 return nativeResponseValue;
21046 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
21048 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
21049 if(!isWasmInitialized) {
21050 throw new Error("initializeWasm() must be awaited first!");
21052 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
21053 // debug statements here
21055 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
21057 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21058 if(!isWasmInitialized) {
21059 throw new Error("initializeWasm() must be awaited first!");
21061 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
21062 return nativeResponseValue;
21064 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
21066 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
21067 if(!isWasmInitialized) {
21068 throw new Error("initializeWasm() must be awaited first!");
21070 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
21071 return nativeResponseValue;
21073 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
21075 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
21076 if(!isWasmInitialized) {
21077 throw new Error("initializeWasm() must be awaited first!");
21079 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
21080 return nativeResponseValue;
21082 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
21084 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
21085 if(!isWasmInitialized) {
21086 throw new Error("initializeWasm() must be awaited first!");
21088 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
21089 return nativeResponseValue;
21091 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
21093 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
21094 if(!isWasmInitialized) {
21095 throw new Error("initializeWasm() must be awaited first!");
21097 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
21098 return nativeResponseValue;
21100 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
21102 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
21103 if(!isWasmInitialized) {
21104 throw new Error("initializeWasm() must be awaited first!");
21106 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
21107 // debug statements here
21109 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
21111 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21112 if(!isWasmInitialized) {
21113 throw new Error("initializeWasm() must be awaited first!");
21115 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
21116 return nativeResponseValue;
21118 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
21120 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
21121 if(!isWasmInitialized) {
21122 throw new Error("initializeWasm() must be awaited first!");
21124 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
21125 return nativeResponseValue;
21127 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
21129 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
21130 if(!isWasmInitialized) {
21131 throw new Error("initializeWasm() must be awaited first!");
21133 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
21134 return nativeResponseValue;
21136 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
21138 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
21139 if(!isWasmInitialized) {
21140 throw new Error("initializeWasm() must be awaited first!");
21142 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
21143 return nativeResponseValue;
21145 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
21147 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
21148 if(!isWasmInitialized) {
21149 throw new Error("initializeWasm() must be awaited first!");
21151 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
21152 return nativeResponseValue;
21154 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
21156 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
21157 if(!isWasmInitialized) {
21158 throw new Error("initializeWasm() must be awaited first!");
21160 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
21161 // debug statements here
21163 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
21165 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21166 if(!isWasmInitialized) {
21167 throw new Error("initializeWasm() must be awaited first!");
21169 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
21170 return nativeResponseValue;
21172 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
21174 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
21175 if(!isWasmInitialized) {
21176 throw new Error("initializeWasm() must be awaited first!");
21178 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
21179 return nativeResponseValue;
21181 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
21183 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
21184 if(!isWasmInitialized) {
21185 throw new Error("initializeWasm() must be awaited first!");
21187 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
21188 return nativeResponseValue;
21190 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
21192 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
21193 if(!isWasmInitialized) {
21194 throw new Error("initializeWasm() must be awaited first!");
21196 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
21197 return nativeResponseValue;
21199 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
21201 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
21202 if(!isWasmInitialized) {
21203 throw new Error("initializeWasm() must be awaited first!");
21205 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
21206 return nativeResponseValue;
21208 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
21210 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
21211 if(!isWasmInitialized) {
21212 throw new Error("initializeWasm() must be awaited first!");
21214 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
21215 // debug statements here
21217 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
21219 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21220 if(!isWasmInitialized) {
21221 throw new Error("initializeWasm() must be awaited first!");
21223 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
21224 return nativeResponseValue;
21226 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
21228 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
21229 if(!isWasmInitialized) {
21230 throw new Error("initializeWasm() must be awaited first!");
21232 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
21233 return nativeResponseValue;
21235 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
21237 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
21238 if(!isWasmInitialized) {
21239 throw new Error("initializeWasm() must be awaited first!");
21241 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
21242 return nativeResponseValue;
21244 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
21246 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
21247 if(!isWasmInitialized) {
21248 throw new Error("initializeWasm() must be awaited first!");
21250 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
21251 return nativeResponseValue;
21253 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
21255 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
21256 if(!isWasmInitialized) {
21257 throw new Error("initializeWasm() must be awaited first!");
21259 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
21260 return nativeResponseValue;
21262 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
21264 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
21265 if(!isWasmInitialized) {
21266 throw new Error("initializeWasm() must be awaited first!");
21268 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
21269 // debug statements here
21271 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
21273 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21274 if(!isWasmInitialized) {
21275 throw new Error("initializeWasm() must be awaited first!");
21277 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
21278 return nativeResponseValue;
21280 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
21282 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
21283 if(!isWasmInitialized) {
21284 throw new Error("initializeWasm() must be awaited first!");
21286 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
21287 return nativeResponseValue;
21289 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
21291 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
21292 if(!isWasmInitialized) {
21293 throw new Error("initializeWasm() must be awaited first!");
21295 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
21296 return nativeResponseValue;
21298 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
21300 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
21301 if(!isWasmInitialized) {
21302 throw new Error("initializeWasm() must be awaited first!");
21304 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
21305 return nativeResponseValue;
21307 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
21309 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
21310 if(!isWasmInitialized) {
21311 throw new Error("initializeWasm() must be awaited first!");
21313 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
21314 return nativeResponseValue;
21316 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
21318 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
21319 if(!isWasmInitialized) {
21320 throw new Error("initializeWasm() must be awaited first!");
21322 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
21323 // debug statements here
21325 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
21327 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21328 if(!isWasmInitialized) {
21329 throw new Error("initializeWasm() must be awaited first!");
21331 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
21332 return nativeResponseValue;
21334 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
21336 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
21337 if(!isWasmInitialized) {
21338 throw new Error("initializeWasm() must be awaited first!");
21340 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
21341 return nativeResponseValue;
21343 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
21345 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
21346 if(!isWasmInitialized) {
21347 throw new Error("initializeWasm() must be awaited first!");
21349 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
21350 return nativeResponseValue;
21352 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
21354 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
21355 if(!isWasmInitialized) {
21356 throw new Error("initializeWasm() must be awaited first!");
21358 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
21359 return nativeResponseValue;
21361 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
21363 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
21364 if(!isWasmInitialized) {
21365 throw new Error("initializeWasm() must be awaited first!");
21367 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
21368 return nativeResponseValue;
21370 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
21372 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
21373 if(!isWasmInitialized) {
21374 throw new Error("initializeWasm() must be awaited first!");
21376 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
21377 // debug statements here
21379 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
21381 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21382 if(!isWasmInitialized) {
21383 throw new Error("initializeWasm() must be awaited first!");
21385 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
21386 return nativeResponseValue;
21388 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
21390 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
21391 if(!isWasmInitialized) {
21392 throw new Error("initializeWasm() must be awaited first!");
21394 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
21395 return nativeResponseValue;
21397 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
21399 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
21400 if(!isWasmInitialized) {
21401 throw new Error("initializeWasm() must be awaited first!");
21403 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
21404 return nativeResponseValue;
21406 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
21408 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
21409 if(!isWasmInitialized) {
21410 throw new Error("initializeWasm() must be awaited first!");
21412 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
21413 return nativeResponseValue;
21415 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
21417 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
21418 if(!isWasmInitialized) {
21419 throw new Error("initializeWasm() must be awaited first!");
21421 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
21422 return nativeResponseValue;
21424 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
21426 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
21427 if(!isWasmInitialized) {
21428 throw new Error("initializeWasm() must be awaited first!");
21430 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
21431 // debug statements here
21433 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
21435 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21436 if(!isWasmInitialized) {
21437 throw new Error("initializeWasm() must be awaited first!");
21439 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
21440 return nativeResponseValue;
21442 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
21444 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
21445 if(!isWasmInitialized) {
21446 throw new Error("initializeWasm() must be awaited first!");
21448 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
21449 return nativeResponseValue;
21451 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
21453 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
21454 if(!isWasmInitialized) {
21455 throw new Error("initializeWasm() must be awaited first!");
21457 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
21458 return nativeResponseValue;
21460 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
21462 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
21463 if(!isWasmInitialized) {
21464 throw new Error("initializeWasm() must be awaited first!");
21466 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
21467 return nativeResponseValue;
21469 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
21471 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
21472 if(!isWasmInitialized) {
21473 throw new Error("initializeWasm() must be awaited first!");
21475 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
21476 return nativeResponseValue;
21478 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
21480 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
21481 if(!isWasmInitialized) {
21482 throw new Error("initializeWasm() must be awaited first!");
21484 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
21485 // debug statements here
21487 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
21489 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21490 if(!isWasmInitialized) {
21491 throw new Error("initializeWasm() must be awaited first!");
21493 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
21494 return nativeResponseValue;
21496 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
21498 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
21499 if(!isWasmInitialized) {
21500 throw new Error("initializeWasm() must be awaited first!");
21502 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
21503 return nativeResponseValue;
21505 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
21507 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
21508 if(!isWasmInitialized) {
21509 throw new Error("initializeWasm() must be awaited first!");
21511 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
21512 return nativeResponseValue;
21514 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
21516 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
21517 if(!isWasmInitialized) {
21518 throw new Error("initializeWasm() must be awaited first!");
21520 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
21521 return nativeResponseValue;
21523 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
21525 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
21526 if(!isWasmInitialized) {
21527 throw new Error("initializeWasm() must be awaited first!");
21529 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
21530 return nativeResponseValue;
21532 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
21534 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
21535 if(!isWasmInitialized) {
21536 throw new Error("initializeWasm() must be awaited first!");
21538 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
21539 // debug statements here
21541 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
21543 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21544 if(!isWasmInitialized) {
21545 throw new Error("initializeWasm() must be awaited first!");
21547 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
21548 return nativeResponseValue;
21550 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
21552 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
21553 if(!isWasmInitialized) {
21554 throw new Error("initializeWasm() must be awaited first!");
21556 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
21557 return nativeResponseValue;
21559 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
21561 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
21562 if(!isWasmInitialized) {
21563 throw new Error("initializeWasm() must be awaited first!");
21565 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
21566 return nativeResponseValue;
21568 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
21570 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
21571 if(!isWasmInitialized) {
21572 throw new Error("initializeWasm() must be awaited first!");
21574 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
21575 return nativeResponseValue;
21577 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
21579 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
21580 if(!isWasmInitialized) {
21581 throw new Error("initializeWasm() must be awaited first!");
21583 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
21584 return nativeResponseValue;
21586 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
21588 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
21589 if(!isWasmInitialized) {
21590 throw new Error("initializeWasm() must be awaited first!");
21592 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
21593 // debug statements here
21595 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
21597 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21598 if(!isWasmInitialized) {
21599 throw new Error("initializeWasm() must be awaited first!");
21601 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
21602 return nativeResponseValue;
21604 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
21606 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
21607 if(!isWasmInitialized) {
21608 throw new Error("initializeWasm() must be awaited first!");
21610 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
21611 return nativeResponseValue;
21613 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
21615 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
21616 if(!isWasmInitialized) {
21617 throw new Error("initializeWasm() must be awaited first!");
21619 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
21620 return nativeResponseValue;
21622 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
21624 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
21625 if(!isWasmInitialized) {
21626 throw new Error("initializeWasm() must be awaited first!");
21628 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
21629 return nativeResponseValue;
21631 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
21633 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
21634 if(!isWasmInitialized) {
21635 throw new Error("initializeWasm() must be awaited first!");
21637 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
21638 return nativeResponseValue;
21640 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
21642 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
21643 if(!isWasmInitialized) {
21644 throw new Error("initializeWasm() must be awaited first!");
21646 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
21647 // debug statements here
21649 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
21651 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21652 if(!isWasmInitialized) {
21653 throw new Error("initializeWasm() must be awaited first!");
21655 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
21656 return nativeResponseValue;
21658 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
21660 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
21661 if(!isWasmInitialized) {
21662 throw new Error("initializeWasm() must be awaited first!");
21664 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
21665 return nativeResponseValue;
21667 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
21669 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
21670 if(!isWasmInitialized) {
21671 throw new Error("initializeWasm() must be awaited first!");
21673 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
21674 return nativeResponseValue;
21676 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
21678 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
21679 if(!isWasmInitialized) {
21680 throw new Error("initializeWasm() must be awaited first!");
21682 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
21683 return nativeResponseValue;
21685 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
21687 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
21688 if(!isWasmInitialized) {
21689 throw new Error("initializeWasm() must be awaited first!");
21691 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
21692 return nativeResponseValue;
21694 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
21696 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
21697 if(!isWasmInitialized) {
21698 throw new Error("initializeWasm() must be awaited first!");
21700 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
21701 // debug statements here
21703 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
21705 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21706 if(!isWasmInitialized) {
21707 throw new Error("initializeWasm() must be awaited first!");
21709 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
21710 return nativeResponseValue;
21712 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
21714 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
21715 if(!isWasmInitialized) {
21716 throw new Error("initializeWasm() must be awaited first!");
21718 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
21719 return nativeResponseValue;
21721 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
21723 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
21724 if(!isWasmInitialized) {
21725 throw new Error("initializeWasm() must be awaited first!");
21727 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
21728 return nativeResponseValue;
21730 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
21732 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
21733 if(!isWasmInitialized) {
21734 throw new Error("initializeWasm() must be awaited first!");
21736 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
21737 return nativeResponseValue;
21739 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
21741 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
21742 if(!isWasmInitialized) {
21743 throw new Error("initializeWasm() must be awaited first!");
21745 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
21746 return nativeResponseValue;
21748 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
21750 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
21751 if(!isWasmInitialized) {
21752 throw new Error("initializeWasm() must be awaited first!");
21754 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
21755 // debug statements here
21757 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
21759 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21760 if(!isWasmInitialized) {
21761 throw new Error("initializeWasm() must be awaited first!");
21763 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
21764 return nativeResponseValue;
21766 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
21768 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
21769 if(!isWasmInitialized) {
21770 throw new Error("initializeWasm() must be awaited first!");
21772 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
21773 return nativeResponseValue;
21775 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
21777 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
21778 if(!isWasmInitialized) {
21779 throw new Error("initializeWasm() must be awaited first!");
21781 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
21782 return nativeResponseValue;
21784 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
21786 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
21787 if(!isWasmInitialized) {
21788 throw new Error("initializeWasm() must be awaited first!");
21790 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
21791 return nativeResponseValue;
21793 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
21795 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
21796 if(!isWasmInitialized) {
21797 throw new Error("initializeWasm() must be awaited first!");
21799 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
21800 return nativeResponseValue;
21802 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
21804 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
21805 if(!isWasmInitialized) {
21806 throw new Error("initializeWasm() must be awaited first!");
21808 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
21809 // debug statements here
21811 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
21813 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21814 if(!isWasmInitialized) {
21815 throw new Error("initializeWasm() must be awaited first!");
21817 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
21818 return nativeResponseValue;
21820 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
21822 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
21823 if(!isWasmInitialized) {
21824 throw new Error("initializeWasm() must be awaited first!");
21826 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
21827 return nativeResponseValue;
21829 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
21831 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
21832 if(!isWasmInitialized) {
21833 throw new Error("initializeWasm() must be awaited first!");
21835 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
21836 return nativeResponseValue;
21838 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
21840 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
21841 if(!isWasmInitialized) {
21842 throw new Error("initializeWasm() must be awaited first!");
21844 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
21845 return nativeResponseValue;
21847 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
21849 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
21850 if(!isWasmInitialized) {
21851 throw new Error("initializeWasm() must be awaited first!");
21853 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
21854 return nativeResponseValue;
21856 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
21858 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
21859 if(!isWasmInitialized) {
21860 throw new Error("initializeWasm() must be awaited first!");
21862 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
21863 // debug statements here
21865 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
21867 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21868 if(!isWasmInitialized) {
21869 throw new Error("initializeWasm() must be awaited first!");
21871 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
21872 return nativeResponseValue;
21874 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
21876 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
21877 if(!isWasmInitialized) {
21878 throw new Error("initializeWasm() must be awaited first!");
21880 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
21881 return nativeResponseValue;
21883 // struct LDKCOption_KeyPairZ COption_KeyPairZ_some(struct LDKSecretKey o);
21885 export function COption_KeyPairZ_some(o: number): bigint {
21886 if(!isWasmInitialized) {
21887 throw new Error("initializeWasm() must be awaited first!");
21889 const nativeResponseValue = wasm.TS_COption_KeyPairZ_some(o);
21890 return nativeResponseValue;
21892 // struct LDKCOption_KeyPairZ COption_KeyPairZ_none(void);
21894 export function COption_KeyPairZ_none(): bigint {
21895 if(!isWasmInitialized) {
21896 throw new Error("initializeWasm() must be awaited first!");
21898 const nativeResponseValue = wasm.TS_COption_KeyPairZ_none();
21899 return nativeResponseValue;
21901 // void COption_KeyPairZ_free(struct LDKCOption_KeyPairZ _res);
21903 export function COption_KeyPairZ_free(_res: bigint): void {
21904 if(!isWasmInitialized) {
21905 throw new Error("initializeWasm() must be awaited first!");
21907 const nativeResponseValue = wasm.TS_COption_KeyPairZ_free(_res);
21908 // debug statements here
21910 // uint64_t COption_KeyPairZ_clone_ptr(LDKCOption_KeyPairZ *NONNULL_PTR arg);
21912 export function COption_KeyPairZ_clone_ptr(arg: bigint): bigint {
21913 if(!isWasmInitialized) {
21914 throw new Error("initializeWasm() must be awaited first!");
21916 const nativeResponseValue = wasm.TS_COption_KeyPairZ_clone_ptr(arg);
21917 return nativeResponseValue;
21919 // struct LDKCOption_KeyPairZ COption_KeyPairZ_clone(const struct LDKCOption_KeyPairZ *NONNULL_PTR orig);
21921 export function COption_KeyPairZ_clone(orig: bigint): bigint {
21922 if(!isWasmInitialized) {
21923 throw new Error("initializeWasm() must be awaited first!");
21925 const nativeResponseValue = wasm.TS_COption_KeyPairZ_clone(orig);
21926 return nativeResponseValue;
21928 // struct LDKCResult_COption_KeyPairZNoneZ CResult_COption_KeyPairZNoneZ_ok(struct LDKCOption_KeyPairZ o);
21930 export function CResult_COption_KeyPairZNoneZ_ok(o: bigint): bigint {
21931 if(!isWasmInitialized) {
21932 throw new Error("initializeWasm() must be awaited first!");
21934 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_ok(o);
21935 return nativeResponseValue;
21937 // struct LDKCResult_COption_KeyPairZNoneZ CResult_COption_KeyPairZNoneZ_err(void);
21939 export function CResult_COption_KeyPairZNoneZ_err(): bigint {
21940 if(!isWasmInitialized) {
21941 throw new Error("initializeWasm() must be awaited first!");
21943 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_err();
21944 return nativeResponseValue;
21946 // bool CResult_COption_KeyPairZNoneZ_is_ok(const struct LDKCResult_COption_KeyPairZNoneZ *NONNULL_PTR o);
21948 export function CResult_COption_KeyPairZNoneZ_is_ok(o: bigint): boolean {
21949 if(!isWasmInitialized) {
21950 throw new Error("initializeWasm() must be awaited first!");
21952 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_is_ok(o);
21953 return nativeResponseValue;
21955 // void CResult_COption_KeyPairZNoneZ_free(struct LDKCResult_COption_KeyPairZNoneZ _res);
21957 export function CResult_COption_KeyPairZNoneZ_free(_res: bigint): void {
21958 if(!isWasmInitialized) {
21959 throw new Error("initializeWasm() must be awaited first!");
21961 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_free(_res);
21962 // debug statements here
21964 // uint64_t CResult_COption_KeyPairZNoneZ_clone_ptr(LDKCResult_COption_KeyPairZNoneZ *NONNULL_PTR arg);
21966 export function CResult_COption_KeyPairZNoneZ_clone_ptr(arg: bigint): bigint {
21967 if(!isWasmInitialized) {
21968 throw new Error("initializeWasm() must be awaited first!");
21970 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_clone_ptr(arg);
21971 return nativeResponseValue;
21973 // struct LDKCResult_COption_KeyPairZNoneZ CResult_COption_KeyPairZNoneZ_clone(const struct LDKCResult_COption_KeyPairZNoneZ *NONNULL_PTR orig);
21975 export function CResult_COption_KeyPairZNoneZ_clone(orig: bigint): bigint {
21976 if(!isWasmInitialized) {
21977 throw new Error("initializeWasm() must be awaited first!");
21979 const nativeResponseValue = wasm.TS_CResult_COption_KeyPairZNoneZ_clone(orig);
21980 return nativeResponseValue;
21982 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_ok(struct LDKInvoiceError o);
21984 export function CResult_InvoiceErrorDecodeErrorZ_ok(o: bigint): bigint {
21985 if(!isWasmInitialized) {
21986 throw new Error("initializeWasm() must be awaited first!");
21988 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_ok(o);
21989 return nativeResponseValue;
21991 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_err(struct LDKDecodeError e);
21993 export function CResult_InvoiceErrorDecodeErrorZ_err(e: bigint): bigint {
21994 if(!isWasmInitialized) {
21995 throw new Error("initializeWasm() must be awaited first!");
21997 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_err(e);
21998 return nativeResponseValue;
22000 // bool CResult_InvoiceErrorDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR o);
22002 export function CResult_InvoiceErrorDecodeErrorZ_is_ok(o: bigint): boolean {
22003 if(!isWasmInitialized) {
22004 throw new Error("initializeWasm() must be awaited first!");
22006 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_is_ok(o);
22007 return nativeResponseValue;
22009 // void CResult_InvoiceErrorDecodeErrorZ_free(struct LDKCResult_InvoiceErrorDecodeErrorZ _res);
22011 export function CResult_InvoiceErrorDecodeErrorZ_free(_res: bigint): void {
22012 if(!isWasmInitialized) {
22013 throw new Error("initializeWasm() must be awaited first!");
22015 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_free(_res);
22016 // debug statements here
22018 // uint64_t CResult_InvoiceErrorDecodeErrorZ_clone_ptr(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR arg);
22020 export function CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22021 if(!isWasmInitialized) {
22022 throw new Error("initializeWasm() must be awaited first!");
22024 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg);
22025 return nativeResponseValue;
22027 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_clone(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR orig);
22029 export function CResult_InvoiceErrorDecodeErrorZ_clone(orig: bigint): bigint {
22030 if(!isWasmInitialized) {
22031 throw new Error("initializeWasm() must be awaited first!");
22033 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone(orig);
22034 return nativeResponseValue;
22036 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
22038 export function COption_FilterZ_some(o: bigint): bigint {
22039 if(!isWasmInitialized) {
22040 throw new Error("initializeWasm() must be awaited first!");
22042 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
22043 return nativeResponseValue;
22045 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
22047 export function COption_FilterZ_none(): bigint {
22048 if(!isWasmInitialized) {
22049 throw new Error("initializeWasm() must be awaited first!");
22051 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
22052 return nativeResponseValue;
22054 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
22056 export function COption_FilterZ_free(_res: bigint): void {
22057 if(!isWasmInitialized) {
22058 throw new Error("initializeWasm() must be awaited first!");
22060 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
22061 // debug statements here
22063 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
22065 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
22066 if(!isWasmInitialized) {
22067 throw new Error("initializeWasm() must be awaited first!");
22069 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
22070 return nativeResponseValue;
22072 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
22074 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
22075 if(!isWasmInitialized) {
22076 throw new Error("initializeWasm() must be awaited first!");
22078 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
22079 return nativeResponseValue;
22081 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
22083 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
22084 if(!isWasmInitialized) {
22085 throw new Error("initializeWasm() must be awaited first!");
22087 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
22088 return nativeResponseValue;
22090 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
22092 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
22093 if(!isWasmInitialized) {
22094 throw new Error("initializeWasm() must be awaited first!");
22096 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
22097 // debug statements here
22099 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
22101 export function CVec_OutPointZ_free(_res: number): void {
22102 if(!isWasmInitialized) {
22103 throw new Error("initializeWasm() must be awaited first!");
22105 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
22106 // debug statements here
22108 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
22110 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
22111 if(!isWasmInitialized) {
22112 throw new Error("initializeWasm() must be awaited first!");
22114 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
22115 // debug statements here
22117 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
22119 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
22120 if(!isWasmInitialized) {
22121 throw new Error("initializeWasm() must be awaited first!");
22123 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
22124 return nativeResponseValue;
22126 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
22128 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
22129 if(!isWasmInitialized) {
22130 throw new Error("initializeWasm() must be awaited first!");
22132 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
22133 return nativeResponseValue;
22135 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
22137 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
22138 if(!isWasmInitialized) {
22139 throw new Error("initializeWasm() must be awaited first!");
22141 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
22142 return nativeResponseValue;
22144 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
22146 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
22147 if(!isWasmInitialized) {
22148 throw new Error("initializeWasm() must be awaited first!");
22150 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
22151 // debug statements here
22153 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
22155 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
22156 if(!isWasmInitialized) {
22157 throw new Error("initializeWasm() must be awaited first!");
22159 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
22160 // debug statements here
22162 // void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
22164 export function CVec_PhantomRouteHintsZ_free(_res: number): void {
22165 if(!isWasmInitialized) {
22166 throw new Error("initializeWasm() must be awaited first!");
22168 const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
22169 // debug statements here
22171 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(struct LDKBolt11Invoice o);
22173 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
22174 if(!isWasmInitialized) {
22175 throw new Error("initializeWasm() must be awaited first!");
22177 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o);
22178 return nativeResponseValue;
22180 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
22182 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
22183 if(!isWasmInitialized) {
22184 throw new Error("initializeWasm() must be awaited first!");
22186 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e);
22187 return nativeResponseValue;
22189 // bool CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
22191 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
22192 if(!isWasmInitialized) {
22193 throw new Error("initializeWasm() must be awaited first!");
22195 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o);
22196 return nativeResponseValue;
22198 // void CResult_Bolt11InvoiceSignOrCreationErrorZ_free(struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ _res);
22200 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
22201 if(!isWasmInitialized) {
22202 throw new Error("initializeWasm() must be awaited first!");
22204 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res);
22205 // debug statements here
22207 // uint64_t CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
22209 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
22210 if(!isWasmInitialized) {
22211 throw new Error("initializeWasm() must be awaited first!");
22213 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg);
22214 return nativeResponseValue;
22216 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
22218 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
22219 if(!isWasmInitialized) {
22220 throw new Error("initializeWasm() must be awaited first!");
22222 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig);
22223 return nativeResponseValue;
22225 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_ok(enum LDKSiPrefix o);
22227 export function CResult_SiPrefixBolt11ParseErrorZ_ok(o: SiPrefix): bigint {
22228 if(!isWasmInitialized) {
22229 throw new Error("initializeWasm() must be awaited first!");
22231 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_ok(o);
22232 return nativeResponseValue;
22234 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
22236 export function CResult_SiPrefixBolt11ParseErrorZ_err(e: bigint): bigint {
22237 if(!isWasmInitialized) {
22238 throw new Error("initializeWasm() must be awaited first!");
22240 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_err(e);
22241 return nativeResponseValue;
22243 // bool CResult_SiPrefixBolt11ParseErrorZ_is_ok(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR o);
22245 export function CResult_SiPrefixBolt11ParseErrorZ_is_ok(o: bigint): boolean {
22246 if(!isWasmInitialized) {
22247 throw new Error("initializeWasm() must be awaited first!");
22249 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok(o);
22250 return nativeResponseValue;
22252 // void CResult_SiPrefixBolt11ParseErrorZ_free(struct LDKCResult_SiPrefixBolt11ParseErrorZ _res);
22254 export function CResult_SiPrefixBolt11ParseErrorZ_free(_res: bigint): void {
22255 if(!isWasmInitialized) {
22256 throw new Error("initializeWasm() must be awaited first!");
22258 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_free(_res);
22259 // debug statements here
22261 // uint64_t CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR arg);
22263 export function CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
22264 if(!isWasmInitialized) {
22265 throw new Error("initializeWasm() must be awaited first!");
22267 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg);
22268 return nativeResponseValue;
22270 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_clone(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR orig);
22272 export function CResult_SiPrefixBolt11ParseErrorZ_clone(orig: bigint): bigint {
22273 if(!isWasmInitialized) {
22274 throw new Error("initializeWasm() must be awaited first!");
22276 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone(orig);
22277 return nativeResponseValue;
22279 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(struct LDKBolt11Invoice o);
22281 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
22282 if(!isWasmInitialized) {
22283 throw new Error("initializeWasm() must be awaited first!");
22285 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o);
22286 return nativeResponseValue;
22288 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
22290 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
22291 if(!isWasmInitialized) {
22292 throw new Error("initializeWasm() must be awaited first!");
22294 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e);
22295 return nativeResponseValue;
22297 // bool CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
22299 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
22300 if(!isWasmInitialized) {
22301 throw new Error("initializeWasm() must be awaited first!");
22303 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o);
22304 return nativeResponseValue;
22306 // void CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ _res);
22308 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
22309 if(!isWasmInitialized) {
22310 throw new Error("initializeWasm() must be awaited first!");
22312 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res);
22313 // debug statements here
22315 // uint64_t CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
22317 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
22318 if(!isWasmInitialized) {
22319 throw new Error("initializeWasm() must be awaited first!");
22321 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
22322 return nativeResponseValue;
22324 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
22326 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
22327 if(!isWasmInitialized) {
22328 throw new Error("initializeWasm() must be awaited first!");
22330 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig);
22331 return nativeResponseValue;
22333 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(struct LDKSignedRawBolt11Invoice o);
22335 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o: bigint): bigint {
22336 if(!isWasmInitialized) {
22337 throw new Error("initializeWasm() must be awaited first!");
22339 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o);
22340 return nativeResponseValue;
22342 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
22344 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e: bigint): bigint {
22345 if(!isWasmInitialized) {
22346 throw new Error("initializeWasm() must be awaited first!");
22348 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e);
22349 return nativeResponseValue;
22351 // bool CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR o);
22353 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o: bigint): boolean {
22354 if(!isWasmInitialized) {
22355 throw new Error("initializeWasm() must be awaited first!");
22357 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o);
22358 return nativeResponseValue;
22360 // void CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ _res);
22362 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res: bigint): void {
22363 if(!isWasmInitialized) {
22364 throw new Error("initializeWasm() must be awaited first!");
22366 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res);
22367 // debug statements here
22369 // uint64_t CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR arg);
22371 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
22372 if(!isWasmInitialized) {
22373 throw new Error("initializeWasm() must be awaited first!");
22375 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg);
22376 return nativeResponseValue;
22378 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR orig);
22380 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig: bigint): bigint {
22381 if(!isWasmInitialized) {
22382 throw new Error("initializeWasm() must be awaited first!");
22384 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig);
22385 return nativeResponseValue;
22387 // uint64_t C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR arg);
22389 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
22390 if(!isWasmInitialized) {
22391 throw new Error("initializeWasm() must be awaited first!");
22393 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg);
22394 return nativeResponseValue;
22396 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR orig);
22398 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig: bigint): bigint {
22399 if(!isWasmInitialized) {
22400 throw new Error("initializeWasm() must be awaited first!");
22402 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig);
22403 return nativeResponseValue;
22405 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(struct LDKRawBolt11Invoice a, struct LDKThirtyTwoBytes b, struct LDKBolt11InvoiceSignature c);
22407 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
22408 if(!isWasmInitialized) {
22409 throw new Error("initializeWasm() must be awaited first!");
22411 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a, b, c);
22412 return nativeResponseValue;
22414 // void C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ _res);
22416 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res: bigint): void {
22417 if(!isWasmInitialized) {
22418 throw new Error("initializeWasm() must be awaited first!");
22420 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res);
22421 // debug statements here
22423 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
22425 export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
22426 if(!isWasmInitialized) {
22427 throw new Error("initializeWasm() must be awaited first!");
22429 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
22430 return nativeResponseValue;
22432 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
22434 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
22435 if(!isWasmInitialized) {
22436 throw new Error("initializeWasm() must be awaited first!");
22438 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
22439 return nativeResponseValue;
22441 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
22443 export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
22444 if(!isWasmInitialized) {
22445 throw new Error("initializeWasm() must be awaited first!");
22447 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
22448 return nativeResponseValue;
22450 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
22452 export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
22453 if(!isWasmInitialized) {
22454 throw new Error("initializeWasm() must be awaited first!");
22456 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
22457 // debug statements here
22459 // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
22461 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
22462 if(!isWasmInitialized) {
22463 throw new Error("initializeWasm() must be awaited first!");
22465 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
22466 return nativeResponseValue;
22468 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
22470 export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
22471 if(!isWasmInitialized) {
22472 throw new Error("initializeWasm() must be awaited first!");
22474 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
22475 return nativeResponseValue;
22477 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
22479 export function CVec_PrivateRouteZ_free(_res: number): void {
22480 if(!isWasmInitialized) {
22481 throw new Error("initializeWasm() must be awaited first!");
22483 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
22484 // debug statements here
22486 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
22488 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
22489 if(!isWasmInitialized) {
22490 throw new Error("initializeWasm() must be awaited first!");
22492 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
22493 return nativeResponseValue;
22495 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
22497 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
22498 if(!isWasmInitialized) {
22499 throw new Error("initializeWasm() must be awaited first!");
22501 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
22502 return nativeResponseValue;
22504 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
22506 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
22507 if(!isWasmInitialized) {
22508 throw new Error("initializeWasm() must be awaited first!");
22510 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
22511 return nativeResponseValue;
22513 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
22515 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
22516 if(!isWasmInitialized) {
22517 throw new Error("initializeWasm() must be awaited first!");
22519 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
22520 // debug statements here
22522 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
22524 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
22525 if(!isWasmInitialized) {
22526 throw new Error("initializeWasm() must be awaited first!");
22528 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
22529 return nativeResponseValue;
22531 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
22533 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
22534 if(!isWasmInitialized) {
22535 throw new Error("initializeWasm() must be awaited first!");
22537 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
22538 return nativeResponseValue;
22540 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_ok(void);
22542 export function CResult_NoneBolt11SemanticErrorZ_ok(): bigint {
22543 if(!isWasmInitialized) {
22544 throw new Error("initializeWasm() must be awaited first!");
22546 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_ok();
22547 return nativeResponseValue;
22549 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
22551 export function CResult_NoneBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
22552 if(!isWasmInitialized) {
22553 throw new Error("initializeWasm() must be awaited first!");
22555 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_err(e);
22556 return nativeResponseValue;
22558 // bool CResult_NoneBolt11SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR o);
22560 export function CResult_NoneBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
22561 if(!isWasmInitialized) {
22562 throw new Error("initializeWasm() must be awaited first!");
22564 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_is_ok(o);
22565 return nativeResponseValue;
22567 // void CResult_NoneBolt11SemanticErrorZ_free(struct LDKCResult_NoneBolt11SemanticErrorZ _res);
22569 export function CResult_NoneBolt11SemanticErrorZ_free(_res: bigint): void {
22570 if(!isWasmInitialized) {
22571 throw new Error("initializeWasm() must be awaited first!");
22573 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_free(_res);
22574 // debug statements here
22576 // uint64_t CResult_NoneBolt11SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR arg);
22578 export function CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
22579 if(!isWasmInitialized) {
22580 throw new Error("initializeWasm() must be awaited first!");
22582 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg);
22583 return nativeResponseValue;
22585 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_clone(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR orig);
22587 export function CResult_NoneBolt11SemanticErrorZ_clone(orig: bigint): bigint {
22588 if(!isWasmInitialized) {
22589 throw new Error("initializeWasm() must be awaited first!");
22591 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone(orig);
22592 return nativeResponseValue;
22594 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(struct LDKBolt11Invoice o);
22596 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o: bigint): bigint {
22597 if(!isWasmInitialized) {
22598 throw new Error("initializeWasm() must be awaited first!");
22600 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o);
22601 return nativeResponseValue;
22603 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
22605 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
22606 if(!isWasmInitialized) {
22607 throw new Error("initializeWasm() must be awaited first!");
22609 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e);
22610 return nativeResponseValue;
22612 // bool CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR o);
22614 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
22615 if(!isWasmInitialized) {
22616 throw new Error("initializeWasm() must be awaited first!");
22618 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o);
22619 return nativeResponseValue;
22621 // void CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ _res);
22623 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res: bigint): void {
22624 if(!isWasmInitialized) {
22625 throw new Error("initializeWasm() must be awaited first!");
22627 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res);
22628 // debug statements here
22630 // uint64_t CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR arg);
22632 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
22633 if(!isWasmInitialized) {
22634 throw new Error("initializeWasm() must be awaited first!");
22636 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg);
22637 return nativeResponseValue;
22639 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR orig);
22641 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig: bigint): bigint {
22642 if(!isWasmInitialized) {
22643 throw new Error("initializeWasm() must be awaited first!");
22645 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig);
22646 return nativeResponseValue;
22648 // void CVec_AddressZ_free(struct LDKCVec_AddressZ _res);
22650 export function CVec_AddressZ_free(_res: number): void {
22651 if(!isWasmInitialized) {
22652 throw new Error("initializeWasm() must be awaited first!");
22654 const nativeResponseValue = wasm.TS_CVec_AddressZ_free(_res);
22655 // debug statements here
22657 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
22659 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
22660 if(!isWasmInitialized) {
22661 throw new Error("initializeWasm() must be awaited first!");
22663 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
22664 return nativeResponseValue;
22666 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
22668 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
22669 if(!isWasmInitialized) {
22670 throw new Error("initializeWasm() must be awaited first!");
22672 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
22673 return nativeResponseValue;
22675 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
22677 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
22678 if(!isWasmInitialized) {
22679 throw new Error("initializeWasm() must be awaited first!");
22681 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
22682 return nativeResponseValue;
22684 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
22686 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
22687 if(!isWasmInitialized) {
22688 throw new Error("initializeWasm() must be awaited first!");
22690 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
22691 // debug statements here
22693 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
22695 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
22696 if(!isWasmInitialized) {
22697 throw new Error("initializeWasm() must be awaited first!");
22699 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
22700 return nativeResponseValue;
22702 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
22704 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
22705 if(!isWasmInitialized) {
22706 throw new Error("initializeWasm() must be awaited first!");
22708 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
22709 return nativeResponseValue;
22711 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
22713 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
22714 if(!isWasmInitialized) {
22715 throw new Error("initializeWasm() must be awaited first!");
22717 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
22718 return nativeResponseValue;
22720 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
22722 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
22723 if(!isWasmInitialized) {
22724 throw new Error("initializeWasm() must be awaited first!");
22726 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
22727 return nativeResponseValue;
22729 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
22731 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
22732 if(!isWasmInitialized) {
22733 throw new Error("initializeWasm() must be awaited first!");
22735 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
22736 return nativeResponseValue;
22738 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
22740 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
22741 if(!isWasmInitialized) {
22742 throw new Error("initializeWasm() must be awaited first!");
22744 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
22745 // debug statements here
22747 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
22749 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
22750 if(!isWasmInitialized) {
22751 throw new Error("initializeWasm() must be awaited first!");
22753 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
22754 return nativeResponseValue;
22756 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
22758 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
22759 if(!isWasmInitialized) {
22760 throw new Error("initializeWasm() must be awaited first!");
22762 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
22763 return nativeResponseValue;
22765 // void APIError_free(struct LDKAPIError this_ptr);
22767 export function APIError_free(this_ptr: bigint): void {
22768 if(!isWasmInitialized) {
22769 throw new Error("initializeWasm() must be awaited first!");
22771 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
22772 // debug statements here
22774 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
22776 export function APIError_clone_ptr(arg: bigint): bigint {
22777 if(!isWasmInitialized) {
22778 throw new Error("initializeWasm() must be awaited first!");
22780 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
22781 return nativeResponseValue;
22783 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
22785 export function APIError_clone(orig: bigint): bigint {
22786 if(!isWasmInitialized) {
22787 throw new Error("initializeWasm() must be awaited first!");
22789 const nativeResponseValue = wasm.TS_APIError_clone(orig);
22790 return nativeResponseValue;
22792 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
22794 export function APIError_apimisuse_error(err: number): bigint {
22795 if(!isWasmInitialized) {
22796 throw new Error("initializeWasm() must be awaited first!");
22798 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
22799 return nativeResponseValue;
22801 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
22803 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
22804 if(!isWasmInitialized) {
22805 throw new Error("initializeWasm() must be awaited first!");
22807 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
22808 return nativeResponseValue;
22810 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
22812 export function APIError_invalid_route(err: number): bigint {
22813 if(!isWasmInitialized) {
22814 throw new Error("initializeWasm() must be awaited first!");
22816 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
22817 return nativeResponseValue;
22819 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
22821 export function APIError_channel_unavailable(err: number): bigint {
22822 if(!isWasmInitialized) {
22823 throw new Error("initializeWasm() must be awaited first!");
22825 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
22826 return nativeResponseValue;
22828 // struct LDKAPIError APIError_monitor_update_in_progress(void);
22830 export function APIError_monitor_update_in_progress(): bigint {
22831 if(!isWasmInitialized) {
22832 throw new Error("initializeWasm() must be awaited first!");
22834 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
22835 return nativeResponseValue;
22837 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
22839 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
22840 if(!isWasmInitialized) {
22841 throw new Error("initializeWasm() must be awaited first!");
22843 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
22844 return nativeResponseValue;
22846 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
22848 export function APIError_eq(a: bigint, b: bigint): boolean {
22849 if(!isWasmInitialized) {
22850 throw new Error("initializeWasm() must be awaited first!");
22852 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
22853 return nativeResponseValue;
22855 // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
22857 export function APIError_write(obj: bigint): number {
22858 if(!isWasmInitialized) {
22859 throw new Error("initializeWasm() must be awaited first!");
22861 const nativeResponseValue = wasm.TS_APIError_write(obj);
22862 return nativeResponseValue;
22864 // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
22866 export function APIError_read(ser: number): bigint {
22867 if(!isWasmInitialized) {
22868 throw new Error("initializeWasm() must be awaited first!");
22870 const nativeResponseValue = wasm.TS_APIError_read(ser);
22871 return nativeResponseValue;
22873 // void BigSize_free(struct LDKBigSize this_obj);
22875 export function BigSize_free(this_obj: bigint): void {
22876 if(!isWasmInitialized) {
22877 throw new Error("initializeWasm() must be awaited first!");
22879 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
22880 // debug statements here
22882 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
22884 export function BigSize_get_a(this_ptr: bigint): bigint {
22885 if(!isWasmInitialized) {
22886 throw new Error("initializeWasm() must be awaited first!");
22888 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
22889 return nativeResponseValue;
22891 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
22893 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
22894 if(!isWasmInitialized) {
22895 throw new Error("initializeWasm() must be awaited first!");
22897 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
22898 // debug statements here
22900 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
22902 export function BigSize_new(a_arg: bigint): bigint {
22903 if(!isWasmInitialized) {
22904 throw new Error("initializeWasm() must be awaited first!");
22906 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
22907 return nativeResponseValue;
22909 // uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg);
22911 export function BigSize_clone_ptr(arg: bigint): bigint {
22912 if(!isWasmInitialized) {
22913 throw new Error("initializeWasm() must be awaited first!");
22915 const nativeResponseValue = wasm.TS_BigSize_clone_ptr(arg);
22916 return nativeResponseValue;
22918 // struct LDKBigSize BigSize_clone(const struct LDKBigSize *NONNULL_PTR orig);
22920 export function BigSize_clone(orig: bigint): bigint {
22921 if(!isWasmInitialized) {
22922 throw new Error("initializeWasm() must be awaited first!");
22924 const nativeResponseValue = wasm.TS_BigSize_clone(orig);
22925 return nativeResponseValue;
22927 // uint64_t BigSize_hash(const struct LDKBigSize *NONNULL_PTR o);
22929 export function BigSize_hash(o: bigint): bigint {
22930 if(!isWasmInitialized) {
22931 throw new Error("initializeWasm() must be awaited first!");
22933 const nativeResponseValue = wasm.TS_BigSize_hash(o);
22934 return nativeResponseValue;
22936 // bool BigSize_eq(const struct LDKBigSize *NONNULL_PTR a, const struct LDKBigSize *NONNULL_PTR b);
22938 export function BigSize_eq(a: bigint, b: bigint): boolean {
22939 if(!isWasmInitialized) {
22940 throw new Error("initializeWasm() must be awaited first!");
22942 const nativeResponseValue = wasm.TS_BigSize_eq(a, b);
22943 return nativeResponseValue;
22945 // struct LDKCVec_u8Z BigSize_write(const struct LDKBigSize *NONNULL_PTR obj);
22947 export function BigSize_write(obj: bigint): number {
22948 if(!isWasmInitialized) {
22949 throw new Error("initializeWasm() must be awaited first!");
22951 const nativeResponseValue = wasm.TS_BigSize_write(obj);
22952 return nativeResponseValue;
22954 // struct LDKCResult_BigSizeDecodeErrorZ BigSize_read(struct LDKu8slice ser);
22956 export function BigSize_read(ser: number): bigint {
22957 if(!isWasmInitialized) {
22958 throw new Error("initializeWasm() must be awaited first!");
22960 const nativeResponseValue = wasm.TS_BigSize_read(ser);
22961 return nativeResponseValue;
22963 // void Hostname_free(struct LDKHostname this_obj);
22965 export function Hostname_free(this_obj: bigint): void {
22966 if(!isWasmInitialized) {
22967 throw new Error("initializeWasm() must be awaited first!");
22969 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
22970 // debug statements here
22972 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
22974 export function Hostname_clone_ptr(arg: bigint): bigint {
22975 if(!isWasmInitialized) {
22976 throw new Error("initializeWasm() must be awaited first!");
22978 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
22979 return nativeResponseValue;
22981 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
22983 export function Hostname_clone(orig: bigint): bigint {
22984 if(!isWasmInitialized) {
22985 throw new Error("initializeWasm() must be awaited first!");
22987 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
22988 return nativeResponseValue;
22990 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
22992 export function Hostname_eq(a: bigint, b: bigint): boolean {
22993 if(!isWasmInitialized) {
22994 throw new Error("initializeWasm() must be awaited first!");
22996 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
22997 return nativeResponseValue;
22999 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
23001 export function Hostname_len(this_arg: bigint): number {
23002 if(!isWasmInitialized) {
23003 throw new Error("initializeWasm() must be awaited first!");
23005 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
23006 return nativeResponseValue;
23008 // struct LDKCVec_u8Z Hostname_write(const struct LDKHostname *NONNULL_PTR obj);
23010 export function Hostname_write(obj: bigint): number {
23011 if(!isWasmInitialized) {
23012 throw new Error("initializeWasm() must be awaited first!");
23014 const nativeResponseValue = wasm.TS_Hostname_write(obj);
23015 return nativeResponseValue;
23017 // struct LDKCResult_HostnameDecodeErrorZ Hostname_read(struct LDKu8slice ser);
23019 export function Hostname_read(ser: number): bigint {
23020 if(!isWasmInitialized) {
23021 throw new Error("initializeWasm() must be awaited first!");
23023 const nativeResponseValue = wasm.TS_Hostname_read(ser);
23024 return nativeResponseValue;
23026 // void TransactionU16LenLimited_free(struct LDKTransactionU16LenLimited this_obj);
23028 export function TransactionU16LenLimited_free(this_obj: bigint): void {
23029 if(!isWasmInitialized) {
23030 throw new Error("initializeWasm() must be awaited first!");
23032 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_free(this_obj);
23033 // debug statements here
23035 // uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg);
23037 export function TransactionU16LenLimited_clone_ptr(arg: bigint): bigint {
23038 if(!isWasmInitialized) {
23039 throw new Error("initializeWasm() must be awaited first!");
23041 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone_ptr(arg);
23042 return nativeResponseValue;
23044 // struct LDKTransactionU16LenLimited TransactionU16LenLimited_clone(const struct LDKTransactionU16LenLimited *NONNULL_PTR orig);
23046 export function TransactionU16LenLimited_clone(orig: bigint): bigint {
23047 if(!isWasmInitialized) {
23048 throw new Error("initializeWasm() must be awaited first!");
23050 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone(orig);
23051 return nativeResponseValue;
23053 // bool TransactionU16LenLimited_eq(const struct LDKTransactionU16LenLimited *NONNULL_PTR a, const struct LDKTransactionU16LenLimited *NONNULL_PTR b);
23055 export function TransactionU16LenLimited_eq(a: bigint, b: bigint): boolean {
23056 if(!isWasmInitialized) {
23057 throw new Error("initializeWasm() must be awaited first!");
23059 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_eq(a, b);
23060 return nativeResponseValue;
23062 // MUST_USE_RES struct LDKCResult_TransactionU16LenLimitedNoneZ TransactionU16LenLimited_new(struct LDKTransaction transaction);
23064 export function TransactionU16LenLimited_new(transaction: number): bigint {
23065 if(!isWasmInitialized) {
23066 throw new Error("initializeWasm() must be awaited first!");
23068 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_new(transaction);
23069 return nativeResponseValue;
23071 // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_into_transaction(struct LDKTransactionU16LenLimited this_arg);
23073 export function TransactionU16LenLimited_into_transaction(this_arg: bigint): number {
23074 if(!isWasmInitialized) {
23075 throw new Error("initializeWasm() must be awaited first!");
23077 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_into_transaction(this_arg);
23078 return nativeResponseValue;
23080 // struct LDKCVec_u8Z TransactionU16LenLimited_write(const struct LDKTransactionU16LenLimited *NONNULL_PTR obj);
23082 export function TransactionU16LenLimited_write(obj: bigint): number {
23083 if(!isWasmInitialized) {
23084 throw new Error("initializeWasm() must be awaited first!");
23086 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_write(obj);
23087 return nativeResponseValue;
23089 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ TransactionU16LenLimited_read(struct LDKu8slice ser);
23091 export function TransactionU16LenLimited_read(ser: number): bigint {
23092 if(!isWasmInitialized) {
23093 throw new Error("initializeWasm() must be awaited first!");
23095 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_read(ser);
23096 return nativeResponseValue;
23098 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
23100 export function sign(msg: number, sk: number): bigint {
23101 if(!isWasmInitialized) {
23102 throw new Error("initializeWasm() must be awaited first!");
23104 const nativeResponseValue = wasm.TS_sign(msg, sk);
23105 return nativeResponseValue;
23107 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
23109 export function recover_pk(msg: number, sig: number): bigint {
23110 if(!isWasmInitialized) {
23111 throw new Error("initializeWasm() must be awaited first!");
23113 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
23114 return nativeResponseValue;
23116 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
23118 export function verify(msg: number, sig: number, pk: number): boolean {
23119 if(!isWasmInitialized) {
23120 throw new Error("initializeWasm() must be awaited first!");
23122 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
23123 return nativeResponseValue;
23125 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
23127 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
23128 if(!isWasmInitialized) {
23129 throw new Error("initializeWasm() must be awaited first!");
23131 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
23132 return nativeResponseValue;
23134 // void Persister_free(struct LDKPersister this_ptr);
23136 export function Persister_free(this_ptr: bigint): void {
23137 if(!isWasmInitialized) {
23138 throw new Error("initializeWasm() must be awaited first!");
23140 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
23141 // debug statements here
23143 // void UntrustedString_free(struct LDKUntrustedString this_obj);
23145 export function UntrustedString_free(this_obj: bigint): void {
23146 if(!isWasmInitialized) {
23147 throw new Error("initializeWasm() must be awaited first!");
23149 const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
23150 // debug statements here
23152 // struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
23154 export function UntrustedString_get_a(this_ptr: bigint): number {
23155 if(!isWasmInitialized) {
23156 throw new Error("initializeWasm() must be awaited first!");
23158 const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
23159 return nativeResponseValue;
23161 // void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
23163 export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
23164 if(!isWasmInitialized) {
23165 throw new Error("initializeWasm() must be awaited first!");
23167 const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
23168 // debug statements here
23170 // MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
23172 export function UntrustedString_new(a_arg: number): bigint {
23173 if(!isWasmInitialized) {
23174 throw new Error("initializeWasm() must be awaited first!");
23176 const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
23177 return nativeResponseValue;
23179 // uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
23181 export function UntrustedString_clone_ptr(arg: bigint): bigint {
23182 if(!isWasmInitialized) {
23183 throw new Error("initializeWasm() must be awaited first!");
23185 const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
23186 return nativeResponseValue;
23188 // struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
23190 export function UntrustedString_clone(orig: bigint): bigint {
23191 if(!isWasmInitialized) {
23192 throw new Error("initializeWasm() must be awaited first!");
23194 const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
23195 return nativeResponseValue;
23197 // bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
23199 export function UntrustedString_eq(a: bigint, b: bigint): boolean {
23200 if(!isWasmInitialized) {
23201 throw new Error("initializeWasm() must be awaited first!");
23203 const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
23204 return nativeResponseValue;
23206 // struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
23208 export function UntrustedString_write(obj: bigint): number {
23209 if(!isWasmInitialized) {
23210 throw new Error("initializeWasm() must be awaited first!");
23212 const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
23213 return nativeResponseValue;
23215 // struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
23217 export function UntrustedString_read(ser: number): bigint {
23218 if(!isWasmInitialized) {
23219 throw new Error("initializeWasm() must be awaited first!");
23221 const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
23222 return nativeResponseValue;
23224 // void PrintableString_free(struct LDKPrintableString this_obj);
23226 export function PrintableString_free(this_obj: bigint): void {
23227 if(!isWasmInitialized) {
23228 throw new Error("initializeWasm() must be awaited first!");
23230 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
23231 // debug statements here
23233 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
23235 export function PrintableString_get_a(this_ptr: bigint): number {
23236 if(!isWasmInitialized) {
23237 throw new Error("initializeWasm() must be awaited first!");
23239 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
23240 return nativeResponseValue;
23242 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
23244 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
23245 if(!isWasmInitialized) {
23246 throw new Error("initializeWasm() must be awaited first!");
23248 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
23249 // debug statements here
23251 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
23253 export function PrintableString_new(a_arg: number): bigint {
23254 if(!isWasmInitialized) {
23255 throw new Error("initializeWasm() must be awaited first!");
23257 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
23258 return nativeResponseValue;
23260 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
23262 export function FutureCallback_free(this_ptr: bigint): void {
23263 if(!isWasmInitialized) {
23264 throw new Error("initializeWasm() must be awaited first!");
23266 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
23267 // debug statements here
23269 // void Future_free(struct LDKFuture this_obj);
23271 export function Future_free(this_obj: bigint): void {
23272 if(!isWasmInitialized) {
23273 throw new Error("initializeWasm() must be awaited first!");
23275 const nativeResponseValue = wasm.TS_Future_free(this_obj);
23276 // debug statements here
23278 // uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg);
23280 export function Future_clone_ptr(arg: bigint): bigint {
23281 if(!isWasmInitialized) {
23282 throw new Error("initializeWasm() must be awaited first!");
23284 const nativeResponseValue = wasm.TS_Future_clone_ptr(arg);
23285 return nativeResponseValue;
23287 // struct LDKFuture Future_clone(const struct LDKFuture *NONNULL_PTR orig);
23289 export function Future_clone(orig: bigint): bigint {
23290 if(!isWasmInitialized) {
23291 throw new Error("initializeWasm() must be awaited first!");
23293 const nativeResponseValue = wasm.TS_Future_clone(orig);
23294 return nativeResponseValue;
23296 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
23298 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
23299 if(!isWasmInitialized) {
23300 throw new Error("initializeWasm() must be awaited first!");
23302 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
23303 // debug statements here
23305 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
23307 export function Level_clone(orig: bigint): Level {
23308 if(!isWasmInitialized) {
23309 throw new Error("initializeWasm() must be awaited first!");
23311 const nativeResponseValue = wasm.TS_Level_clone(orig);
23312 return nativeResponseValue;
23314 // enum LDKLevel Level_gossip(void);
23316 export function Level_gossip(): Level {
23317 if(!isWasmInitialized) {
23318 throw new Error("initializeWasm() must be awaited first!");
23320 const nativeResponseValue = wasm.TS_Level_gossip();
23321 return nativeResponseValue;
23323 // enum LDKLevel Level_trace(void);
23325 export function Level_trace(): Level {
23326 if(!isWasmInitialized) {
23327 throw new Error("initializeWasm() must be awaited first!");
23329 const nativeResponseValue = wasm.TS_Level_trace();
23330 return nativeResponseValue;
23332 // enum LDKLevel Level_debug(void);
23334 export function Level_debug(): Level {
23335 if(!isWasmInitialized) {
23336 throw new Error("initializeWasm() must be awaited first!");
23338 const nativeResponseValue = wasm.TS_Level_debug();
23339 return nativeResponseValue;
23341 // enum LDKLevel Level_info(void);
23343 export function Level_info(): Level {
23344 if(!isWasmInitialized) {
23345 throw new Error("initializeWasm() must be awaited first!");
23347 const nativeResponseValue = wasm.TS_Level_info();
23348 return nativeResponseValue;
23350 // enum LDKLevel Level_warn(void);
23352 export function Level_warn(): Level {
23353 if(!isWasmInitialized) {
23354 throw new Error("initializeWasm() must be awaited first!");
23356 const nativeResponseValue = wasm.TS_Level_warn();
23357 return nativeResponseValue;
23359 // enum LDKLevel Level_error(void);
23361 export function Level_error(): Level {
23362 if(!isWasmInitialized) {
23363 throw new Error("initializeWasm() must be awaited first!");
23365 const nativeResponseValue = wasm.TS_Level_error();
23366 return nativeResponseValue;
23368 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
23370 export function Level_eq(a: bigint, b: bigint): boolean {
23371 if(!isWasmInitialized) {
23372 throw new Error("initializeWasm() must be awaited first!");
23374 const nativeResponseValue = wasm.TS_Level_eq(a, b);
23375 return nativeResponseValue;
23377 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
23379 export function Level_hash(o: bigint): bigint {
23380 if(!isWasmInitialized) {
23381 throw new Error("initializeWasm() must be awaited first!");
23383 const nativeResponseValue = wasm.TS_Level_hash(o);
23384 return nativeResponseValue;
23386 // MUST_USE_RES enum LDKLevel Level_max(void);
23388 export function Level_max(): Level {
23389 if(!isWasmInitialized) {
23390 throw new Error("initializeWasm() must be awaited first!");
23392 const nativeResponseValue = wasm.TS_Level_max();
23393 return nativeResponseValue;
23395 // void Record_free(struct LDKRecord this_obj);
23397 export function Record_free(this_obj: bigint): void {
23398 if(!isWasmInitialized) {
23399 throw new Error("initializeWasm() must be awaited first!");
23401 const nativeResponseValue = wasm.TS_Record_free(this_obj);
23402 // debug statements here
23404 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
23406 export function Record_get_level(this_ptr: bigint): Level {
23407 if(!isWasmInitialized) {
23408 throw new Error("initializeWasm() must be awaited first!");
23410 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
23411 return nativeResponseValue;
23413 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
23415 export function Record_set_level(this_ptr: bigint, val: Level): void {
23416 if(!isWasmInitialized) {
23417 throw new Error("initializeWasm() must be awaited first!");
23419 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
23420 // debug statements here
23422 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
23424 export function Record_get_args(this_ptr: bigint): number {
23425 if(!isWasmInitialized) {
23426 throw new Error("initializeWasm() must be awaited first!");
23428 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
23429 return nativeResponseValue;
23431 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
23433 export function Record_set_args(this_ptr: bigint, val: number): void {
23434 if(!isWasmInitialized) {
23435 throw new Error("initializeWasm() must be awaited first!");
23437 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
23438 // debug statements here
23440 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
23442 export function Record_get_module_path(this_ptr: bigint): number {
23443 if(!isWasmInitialized) {
23444 throw new Error("initializeWasm() must be awaited first!");
23446 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
23447 return nativeResponseValue;
23449 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
23451 export function Record_set_module_path(this_ptr: bigint, val: number): void {
23452 if(!isWasmInitialized) {
23453 throw new Error("initializeWasm() must be awaited first!");
23455 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
23456 // debug statements here
23458 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
23460 export function Record_get_file(this_ptr: bigint): number {
23461 if(!isWasmInitialized) {
23462 throw new Error("initializeWasm() must be awaited first!");
23464 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
23465 return nativeResponseValue;
23467 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
23469 export function Record_set_file(this_ptr: bigint, val: number): void {
23470 if(!isWasmInitialized) {
23471 throw new Error("initializeWasm() must be awaited first!");
23473 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
23474 // debug statements here
23476 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
23478 export function Record_get_line(this_ptr: bigint): number {
23479 if(!isWasmInitialized) {
23480 throw new Error("initializeWasm() must be awaited first!");
23482 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
23483 return nativeResponseValue;
23485 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
23487 export function Record_set_line(this_ptr: bigint, val: number): void {
23488 if(!isWasmInitialized) {
23489 throw new Error("initializeWasm() must be awaited first!");
23491 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
23492 // debug statements here
23494 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
23496 export function Record_clone_ptr(arg: bigint): bigint {
23497 if(!isWasmInitialized) {
23498 throw new Error("initializeWasm() must be awaited first!");
23500 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
23501 return nativeResponseValue;
23503 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
23505 export function Record_clone(orig: bigint): bigint {
23506 if(!isWasmInitialized) {
23507 throw new Error("initializeWasm() must be awaited first!");
23509 const nativeResponseValue = wasm.TS_Record_clone(orig);
23510 return nativeResponseValue;
23512 // void Logger_free(struct LDKLogger this_ptr);
23514 export function Logger_free(this_ptr: bigint): void {
23515 if(!isWasmInitialized) {
23516 throw new Error("initializeWasm() must be awaited first!");
23518 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
23519 // debug statements here
23521 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
23523 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
23524 if(!isWasmInitialized) {
23525 throw new Error("initializeWasm() must be awaited first!");
23527 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
23528 // debug statements here
23530 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23532 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
23533 if(!isWasmInitialized) {
23534 throw new Error("initializeWasm() must be awaited first!");
23536 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
23537 return nativeResponseValue;
23539 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
23541 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
23542 if(!isWasmInitialized) {
23543 throw new Error("initializeWasm() must be awaited first!");
23545 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
23546 // debug statements here
23548 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23550 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
23551 if(!isWasmInitialized) {
23552 throw new Error("initializeWasm() must be awaited first!");
23554 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
23555 return nativeResponseValue;
23557 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
23559 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
23560 if(!isWasmInitialized) {
23561 throw new Error("initializeWasm() must be awaited first!");
23563 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
23564 // debug statements here
23566 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23568 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
23569 if(!isWasmInitialized) {
23570 throw new Error("initializeWasm() must be awaited first!");
23572 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
23573 return nativeResponseValue;
23575 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
23577 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
23578 if(!isWasmInitialized) {
23579 throw new Error("initializeWasm() must be awaited first!");
23581 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
23582 // debug statements here
23584 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23586 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
23587 if(!isWasmInitialized) {
23588 throw new Error("initializeWasm() must be awaited first!");
23590 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
23591 return nativeResponseValue;
23593 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
23595 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
23596 if(!isWasmInitialized) {
23597 throw new Error("initializeWasm() must be awaited first!");
23599 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
23600 // debug statements here
23602 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23604 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
23605 if(!isWasmInitialized) {
23606 throw new Error("initializeWasm() must be awaited first!");
23608 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
23609 return nativeResponseValue;
23611 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
23613 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
23614 if(!isWasmInitialized) {
23615 throw new Error("initializeWasm() must be awaited first!");
23617 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
23618 // debug statements here
23620 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23622 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
23623 if(!isWasmInitialized) {
23624 throw new Error("initializeWasm() must be awaited first!");
23626 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
23627 return nativeResponseValue;
23629 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
23631 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
23632 if(!isWasmInitialized) {
23633 throw new Error("initializeWasm() must be awaited first!");
23635 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
23636 // debug statements here
23638 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23640 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
23641 if(!isWasmInitialized) {
23642 throw new Error("initializeWasm() must be awaited first!");
23644 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
23645 return nativeResponseValue;
23647 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
23649 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
23650 if(!isWasmInitialized) {
23651 throw new Error("initializeWasm() must be awaited first!");
23653 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
23654 // debug statements here
23656 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23658 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
23659 if(!isWasmInitialized) {
23660 throw new Error("initializeWasm() must be awaited first!");
23662 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
23663 return nativeResponseValue;
23665 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
23667 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
23668 if(!isWasmInitialized) {
23669 throw new Error("initializeWasm() must be awaited first!");
23671 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
23672 // debug statements here
23674 // bool ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23676 export function ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint): boolean {
23677 if(!isWasmInitialized) {
23678 throw new Error("initializeWasm() must be awaited first!");
23680 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr);
23681 return nativeResponseValue;
23683 // void ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
23685 export function ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint, val: boolean): void {
23686 if(!isWasmInitialized) {
23687 throw new Error("initializeWasm() must be awaited first!");
23689 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr, val);
23690 // debug statements here
23692 // uint16_t ChannelHandshakeConfig_get_our_max_accepted_htlcs(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
23694 export function ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr: bigint): number {
23695 if(!isWasmInitialized) {
23696 throw new Error("initializeWasm() must be awaited first!");
23698 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr);
23699 return nativeResponseValue;
23701 // void ChannelHandshakeConfig_set_our_max_accepted_htlcs(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
23703 export function ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr: bigint, val: number): void {
23704 if(!isWasmInitialized) {
23705 throw new Error("initializeWasm() must be awaited first!");
23707 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr, val);
23708 // debug statements here
23710 // 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, bool negotiate_anchors_zero_fee_htlc_tx_arg, uint16_t our_max_accepted_htlcs_arg);
23712 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, negotiate_anchors_zero_fee_htlc_tx_arg: boolean, our_max_accepted_htlcs_arg: number): bigint {
23713 if(!isWasmInitialized) {
23714 throw new Error("initializeWasm() must be awaited first!");
23716 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, negotiate_anchors_zero_fee_htlc_tx_arg, our_max_accepted_htlcs_arg);
23717 return nativeResponseValue;
23719 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
23721 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
23722 if(!isWasmInitialized) {
23723 throw new Error("initializeWasm() must be awaited first!");
23725 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
23726 return nativeResponseValue;
23728 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
23730 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
23731 if(!isWasmInitialized) {
23732 throw new Error("initializeWasm() must be awaited first!");
23734 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
23735 return nativeResponseValue;
23737 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
23739 export function ChannelHandshakeConfig_default(): bigint {
23740 if(!isWasmInitialized) {
23741 throw new Error("initializeWasm() must be awaited first!");
23743 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
23744 return nativeResponseValue;
23746 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
23748 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
23749 if(!isWasmInitialized) {
23750 throw new Error("initializeWasm() must be awaited first!");
23752 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
23753 // debug statements here
23755 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23757 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
23758 if(!isWasmInitialized) {
23759 throw new Error("initializeWasm() must be awaited first!");
23761 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
23762 return nativeResponseValue;
23764 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
23766 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
23767 if(!isWasmInitialized) {
23768 throw new Error("initializeWasm() must be awaited first!");
23770 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
23771 // debug statements here
23773 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23775 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
23776 if(!isWasmInitialized) {
23777 throw new Error("initializeWasm() must be awaited first!");
23779 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
23780 return nativeResponseValue;
23782 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
23784 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
23785 if(!isWasmInitialized) {
23786 throw new Error("initializeWasm() must be awaited first!");
23788 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
23789 // debug statements here
23791 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23793 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
23794 if(!isWasmInitialized) {
23795 throw new Error("initializeWasm() must be awaited first!");
23797 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
23798 return nativeResponseValue;
23800 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
23802 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
23803 if(!isWasmInitialized) {
23804 throw new Error("initializeWasm() must be awaited first!");
23806 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
23807 // debug statements here
23809 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23811 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
23812 if(!isWasmInitialized) {
23813 throw new Error("initializeWasm() must be awaited first!");
23815 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
23816 return nativeResponseValue;
23818 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
23820 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
23821 if(!isWasmInitialized) {
23822 throw new Error("initializeWasm() must be awaited first!");
23824 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
23825 // debug statements here
23827 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23829 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
23830 if(!isWasmInitialized) {
23831 throw new Error("initializeWasm() must be awaited first!");
23833 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
23834 return nativeResponseValue;
23836 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
23838 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
23839 if(!isWasmInitialized) {
23840 throw new Error("initializeWasm() must be awaited first!");
23842 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
23843 // debug statements here
23845 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23847 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
23848 if(!isWasmInitialized) {
23849 throw new Error("initializeWasm() must be awaited first!");
23851 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
23852 return nativeResponseValue;
23854 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
23856 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
23857 if(!isWasmInitialized) {
23858 throw new Error("initializeWasm() must be awaited first!");
23860 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
23861 // debug statements here
23863 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23865 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
23866 if(!isWasmInitialized) {
23867 throw new Error("initializeWasm() must be awaited first!");
23869 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
23870 return nativeResponseValue;
23872 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
23874 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
23875 if(!isWasmInitialized) {
23876 throw new Error("initializeWasm() must be awaited first!");
23878 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
23879 // debug statements here
23881 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23883 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
23884 if(!isWasmInitialized) {
23885 throw new Error("initializeWasm() must be awaited first!");
23887 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
23888 return nativeResponseValue;
23890 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
23892 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
23893 if(!isWasmInitialized) {
23894 throw new Error("initializeWasm() must be awaited first!");
23896 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
23897 // debug statements here
23899 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23901 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
23902 if(!isWasmInitialized) {
23903 throw new Error("initializeWasm() must be awaited first!");
23905 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
23906 return nativeResponseValue;
23908 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
23910 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
23911 if(!isWasmInitialized) {
23912 throw new Error("initializeWasm() must be awaited first!");
23914 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
23915 // debug statements here
23917 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
23919 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
23920 if(!isWasmInitialized) {
23921 throw new Error("initializeWasm() must be awaited first!");
23923 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
23924 return nativeResponseValue;
23926 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
23928 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
23929 if(!isWasmInitialized) {
23930 throw new Error("initializeWasm() must be awaited first!");
23932 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
23933 // debug statements here
23935 // 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);
23937 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 {
23938 if(!isWasmInitialized) {
23939 throw new Error("initializeWasm() must be awaited first!");
23941 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);
23942 return nativeResponseValue;
23944 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
23946 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
23947 if(!isWasmInitialized) {
23948 throw new Error("initializeWasm() must be awaited first!");
23950 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
23951 return nativeResponseValue;
23953 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
23955 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
23956 if(!isWasmInitialized) {
23957 throw new Error("initializeWasm() must be awaited first!");
23959 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
23960 return nativeResponseValue;
23962 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
23964 export function ChannelHandshakeLimits_default(): bigint {
23965 if(!isWasmInitialized) {
23966 throw new Error("initializeWasm() must be awaited first!");
23968 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
23969 return nativeResponseValue;
23971 // void MaxDustHTLCExposure_free(struct LDKMaxDustHTLCExposure this_ptr);
23973 export function MaxDustHTLCExposure_free(this_ptr: bigint): void {
23974 if(!isWasmInitialized) {
23975 throw new Error("initializeWasm() must be awaited first!");
23977 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_free(this_ptr);
23978 // debug statements here
23980 // uint64_t MaxDustHTLCExposure_clone_ptr(LDKMaxDustHTLCExposure *NONNULL_PTR arg);
23982 export function MaxDustHTLCExposure_clone_ptr(arg: bigint): bigint {
23983 if(!isWasmInitialized) {
23984 throw new Error("initializeWasm() must be awaited first!");
23986 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone_ptr(arg);
23987 return nativeResponseValue;
23989 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_clone(const struct LDKMaxDustHTLCExposure *NONNULL_PTR orig);
23991 export function MaxDustHTLCExposure_clone(orig: bigint): bigint {
23992 if(!isWasmInitialized) {
23993 throw new Error("initializeWasm() must be awaited first!");
23995 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone(orig);
23996 return nativeResponseValue;
23998 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fixed_limit_msat(uint64_t a);
24000 export function MaxDustHTLCExposure_fixed_limit_msat(a: bigint): bigint {
24001 if(!isWasmInitialized) {
24002 throw new Error("initializeWasm() must be awaited first!");
24004 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fixed_limit_msat(a);
24005 return nativeResponseValue;
24007 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fee_rate_multiplier(uint64_t a);
24009 export function MaxDustHTLCExposure_fee_rate_multiplier(a: bigint): bigint {
24010 if(!isWasmInitialized) {
24011 throw new Error("initializeWasm() must be awaited first!");
24013 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fee_rate_multiplier(a);
24014 return nativeResponseValue;
24016 // bool MaxDustHTLCExposure_eq(const struct LDKMaxDustHTLCExposure *NONNULL_PTR a, const struct LDKMaxDustHTLCExposure *NONNULL_PTR b);
24018 export function MaxDustHTLCExposure_eq(a: bigint, b: bigint): boolean {
24019 if(!isWasmInitialized) {
24020 throw new Error("initializeWasm() must be awaited first!");
24022 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_eq(a, b);
24023 return nativeResponseValue;
24025 // struct LDKCVec_u8Z MaxDustHTLCExposure_write(const struct LDKMaxDustHTLCExposure *NONNULL_PTR obj);
24027 export function MaxDustHTLCExposure_write(obj: bigint): number {
24028 if(!isWasmInitialized) {
24029 throw new Error("initializeWasm() must be awaited first!");
24031 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_write(obj);
24032 return nativeResponseValue;
24034 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ MaxDustHTLCExposure_read(struct LDKu8slice ser);
24036 export function MaxDustHTLCExposure_read(ser: number): bigint {
24037 if(!isWasmInitialized) {
24038 throw new Error("initializeWasm() must be awaited first!");
24040 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_read(ser);
24041 return nativeResponseValue;
24043 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
24045 export function ChannelConfig_free(this_obj: bigint): void {
24046 if(!isWasmInitialized) {
24047 throw new Error("initializeWasm() must be awaited first!");
24049 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
24050 // debug statements here
24052 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
24054 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
24055 if(!isWasmInitialized) {
24056 throw new Error("initializeWasm() must be awaited first!");
24058 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
24059 return nativeResponseValue;
24061 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
24063 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
24064 if(!isWasmInitialized) {
24065 throw new Error("initializeWasm() must be awaited first!");
24067 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
24068 // debug statements here
24070 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
24072 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
24073 if(!isWasmInitialized) {
24074 throw new Error("initializeWasm() must be awaited first!");
24076 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
24077 return nativeResponseValue;
24079 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
24081 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
24082 if(!isWasmInitialized) {
24083 throw new Error("initializeWasm() must be awaited first!");
24085 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
24086 // debug statements here
24088 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
24090 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
24091 if(!isWasmInitialized) {
24092 throw new Error("initializeWasm() must be awaited first!");
24094 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
24095 return nativeResponseValue;
24097 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
24099 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
24100 if(!isWasmInitialized) {
24101 throw new Error("initializeWasm() must be awaited first!");
24103 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
24104 // debug statements here
24106 // struct LDKMaxDustHTLCExposure ChannelConfig_get_max_dust_htlc_exposure(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
24108 export function ChannelConfig_get_max_dust_htlc_exposure(this_ptr: bigint): bigint {
24109 if(!isWasmInitialized) {
24110 throw new Error("initializeWasm() must be awaited first!");
24112 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure(this_ptr);
24113 return nativeResponseValue;
24115 // void ChannelConfig_set_max_dust_htlc_exposure(struct LDKChannelConfig *NONNULL_PTR this_ptr, struct LDKMaxDustHTLCExposure val);
24117 export function ChannelConfig_set_max_dust_htlc_exposure(this_ptr: bigint, val: bigint): void {
24118 if(!isWasmInitialized) {
24119 throw new Error("initializeWasm() must be awaited first!");
24121 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure(this_ptr, val);
24122 // debug statements here
24124 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
24126 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
24127 if(!isWasmInitialized) {
24128 throw new Error("initializeWasm() must be awaited first!");
24130 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
24131 return nativeResponseValue;
24133 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
24135 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
24136 if(!isWasmInitialized) {
24137 throw new Error("initializeWasm() must be awaited first!");
24139 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
24140 // debug statements here
24142 // bool ChannelConfig_get_accept_underpaying_htlcs(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
24144 export function ChannelConfig_get_accept_underpaying_htlcs(this_ptr: bigint): boolean {
24145 if(!isWasmInitialized) {
24146 throw new Error("initializeWasm() must be awaited first!");
24148 const nativeResponseValue = wasm.TS_ChannelConfig_get_accept_underpaying_htlcs(this_ptr);
24149 return nativeResponseValue;
24151 // void ChannelConfig_set_accept_underpaying_htlcs(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
24153 export function ChannelConfig_set_accept_underpaying_htlcs(this_ptr: bigint, val: boolean): void {
24154 if(!isWasmInitialized) {
24155 throw new Error("initializeWasm() must be awaited first!");
24157 const nativeResponseValue = wasm.TS_ChannelConfig_set_accept_underpaying_htlcs(this_ptr, val);
24158 // debug statements here
24160 // 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, struct LDKMaxDustHTLCExposure max_dust_htlc_exposure_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg, bool accept_underpaying_htlcs_arg);
24162 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_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint, accept_underpaying_htlcs_arg: boolean): bigint {
24163 if(!isWasmInitialized) {
24164 throw new Error("initializeWasm() must be awaited first!");
24166 const nativeResponseValue = wasm.TS_ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_arg, force_close_avoidance_max_fee_satoshis_arg, accept_underpaying_htlcs_arg);
24167 return nativeResponseValue;
24169 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
24171 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
24172 if(!isWasmInitialized) {
24173 throw new Error("initializeWasm() must be awaited first!");
24175 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
24176 return nativeResponseValue;
24178 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
24180 export function ChannelConfig_clone(orig: bigint): bigint {
24181 if(!isWasmInitialized) {
24182 throw new Error("initializeWasm() must be awaited first!");
24184 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
24185 return nativeResponseValue;
24187 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
24189 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
24190 if(!isWasmInitialized) {
24191 throw new Error("initializeWasm() must be awaited first!");
24193 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
24194 return nativeResponseValue;
24196 // void ChannelConfig_apply(struct LDKChannelConfig *NONNULL_PTR this_arg, const struct LDKChannelConfigUpdate *NONNULL_PTR update);
24198 export function ChannelConfig_apply(this_arg: bigint, update: bigint): void {
24199 if(!isWasmInitialized) {
24200 throw new Error("initializeWasm() must be awaited first!");
24202 const nativeResponseValue = wasm.TS_ChannelConfig_apply(this_arg, update);
24203 // debug statements here
24205 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
24207 export function ChannelConfig_default(): bigint {
24208 if(!isWasmInitialized) {
24209 throw new Error("initializeWasm() must be awaited first!");
24211 const nativeResponseValue = wasm.TS_ChannelConfig_default();
24212 return nativeResponseValue;
24214 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
24216 export function ChannelConfig_write(obj: bigint): number {
24217 if(!isWasmInitialized) {
24218 throw new Error("initializeWasm() must be awaited first!");
24220 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
24221 return nativeResponseValue;
24223 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
24225 export function ChannelConfig_read(ser: number): bigint {
24226 if(!isWasmInitialized) {
24227 throw new Error("initializeWasm() must be awaited first!");
24229 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
24230 return nativeResponseValue;
24232 // void ChannelConfigUpdate_free(struct LDKChannelConfigUpdate this_obj);
24234 export function ChannelConfigUpdate_free(this_obj: bigint): void {
24235 if(!isWasmInitialized) {
24236 throw new Error("initializeWasm() must be awaited first!");
24238 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_free(this_obj);
24239 // debug statements here
24241 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
24243 export function ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr: bigint): bigint {
24244 if(!isWasmInitialized) {
24245 throw new Error("initializeWasm() must be awaited first!");
24247 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr);
24248 return nativeResponseValue;
24250 // void ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
24252 export function ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: bigint): void {
24253 if(!isWasmInitialized) {
24254 throw new Error("initializeWasm() must be awaited first!");
24256 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr, val);
24257 // debug statements here
24259 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_base_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
24261 export function ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr: bigint): bigint {
24262 if(!isWasmInitialized) {
24263 throw new Error("initializeWasm() must be awaited first!");
24265 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr);
24266 return nativeResponseValue;
24268 // void ChannelConfigUpdate_set_forwarding_fee_base_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
24270 export function ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr: bigint, val: bigint): void {
24271 if(!isWasmInitialized) {
24272 throw new Error("initializeWasm() must be awaited first!");
24274 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr, val);
24275 // debug statements here
24277 // struct LDKCOption_u16Z ChannelConfigUpdate_get_cltv_expiry_delta(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
24279 export function ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr: bigint): bigint {
24280 if(!isWasmInitialized) {
24281 throw new Error("initializeWasm() must be awaited first!");
24283 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr);
24284 return nativeResponseValue;
24286 // void ChannelConfigUpdate_set_cltv_expiry_delta(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
24288 export function ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: bigint): void {
24289 if(!isWasmInitialized) {
24290 throw new Error("initializeWasm() must be awaited first!");
24292 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr, val);
24293 // debug statements here
24295 // struct LDKCOption_MaxDustHTLCExposureZ ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
24297 export function ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
24298 if(!isWasmInitialized) {
24299 throw new Error("initializeWasm() must be awaited first!");
24301 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr);
24302 return nativeResponseValue;
24304 // void ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_MaxDustHTLCExposureZ val);
24306 export function ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
24307 if(!isWasmInitialized) {
24308 throw new Error("initializeWasm() must be awaited first!");
24310 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr, val);
24311 // debug statements here
24313 // struct LDKCOption_u64Z ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
24315 export function ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
24316 if(!isWasmInitialized) {
24317 throw new Error("initializeWasm() must be awaited first!");
24319 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr);
24320 return nativeResponseValue;
24322 // void ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
24324 export function ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
24325 if(!isWasmInitialized) {
24326 throw new Error("initializeWasm() must be awaited first!");
24328 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
24329 // debug statements here
24331 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_new(struct LDKCOption_u32Z forwarding_fee_proportional_millionths_arg, struct LDKCOption_u32Z forwarding_fee_base_msat_arg, struct LDKCOption_u16Z cltv_expiry_delta_arg, struct LDKCOption_MaxDustHTLCExposureZ max_dust_htlc_exposure_msat_arg, struct LDKCOption_u64Z force_close_avoidance_max_fee_satoshis_arg);
24333 export function ChannelConfigUpdate_new(forwarding_fee_proportional_millionths_arg: bigint, forwarding_fee_base_msat_arg: bigint, cltv_expiry_delta_arg: bigint, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): bigint {
24334 if(!isWasmInitialized) {
24335 throw new Error("initializeWasm() must be awaited first!");
24337 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_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);
24338 return nativeResponseValue;
24340 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_default(void);
24342 export function ChannelConfigUpdate_default(): bigint {
24343 if(!isWasmInitialized) {
24344 throw new Error("initializeWasm() must be awaited first!");
24346 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_default();
24347 return nativeResponseValue;
24349 // void UserConfig_free(struct LDKUserConfig this_obj);
24351 export function UserConfig_free(this_obj: bigint): void {
24352 if(!isWasmInitialized) {
24353 throw new Error("initializeWasm() must be awaited first!");
24355 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
24356 // debug statements here
24358 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24360 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
24361 if(!isWasmInitialized) {
24362 throw new Error("initializeWasm() must be awaited first!");
24364 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
24365 return nativeResponseValue;
24367 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
24369 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
24370 if(!isWasmInitialized) {
24371 throw new Error("initializeWasm() must be awaited first!");
24373 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
24374 // debug statements here
24376 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24378 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
24379 if(!isWasmInitialized) {
24380 throw new Error("initializeWasm() must be awaited first!");
24382 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
24383 return nativeResponseValue;
24385 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
24387 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
24388 if(!isWasmInitialized) {
24389 throw new Error("initializeWasm() must be awaited first!");
24391 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
24392 // debug statements here
24394 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24396 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
24397 if(!isWasmInitialized) {
24398 throw new Error("initializeWasm() must be awaited first!");
24400 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
24401 return nativeResponseValue;
24403 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
24405 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
24406 if(!isWasmInitialized) {
24407 throw new Error("initializeWasm() must be awaited first!");
24409 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
24410 // debug statements here
24412 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24414 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
24415 if(!isWasmInitialized) {
24416 throw new Error("initializeWasm() must be awaited first!");
24418 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
24419 return nativeResponseValue;
24421 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
24423 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
24424 if(!isWasmInitialized) {
24425 throw new Error("initializeWasm() must be awaited first!");
24427 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
24428 // debug statements here
24430 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24432 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
24433 if(!isWasmInitialized) {
24434 throw new Error("initializeWasm() must be awaited first!");
24436 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
24437 return nativeResponseValue;
24439 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
24441 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
24442 if(!isWasmInitialized) {
24443 throw new Error("initializeWasm() must be awaited first!");
24445 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
24446 // debug statements here
24448 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24450 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
24451 if(!isWasmInitialized) {
24452 throw new Error("initializeWasm() must be awaited first!");
24454 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
24455 return nativeResponseValue;
24457 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
24459 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
24460 if(!isWasmInitialized) {
24461 throw new Error("initializeWasm() must be awaited first!");
24463 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
24464 // debug statements here
24466 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24468 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
24469 if(!isWasmInitialized) {
24470 throw new Error("initializeWasm() must be awaited first!");
24472 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
24473 return nativeResponseValue;
24475 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
24477 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
24478 if(!isWasmInitialized) {
24479 throw new Error("initializeWasm() must be awaited first!");
24481 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
24482 // debug statements here
24484 // bool UserConfig_get_accept_mpp_keysend(const struct LDKUserConfig *NONNULL_PTR this_ptr);
24486 export function UserConfig_get_accept_mpp_keysend(this_ptr: bigint): boolean {
24487 if(!isWasmInitialized) {
24488 throw new Error("initializeWasm() must be awaited first!");
24490 const nativeResponseValue = wasm.TS_UserConfig_get_accept_mpp_keysend(this_ptr);
24491 return nativeResponseValue;
24493 // void UserConfig_set_accept_mpp_keysend(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
24495 export function UserConfig_set_accept_mpp_keysend(this_ptr: bigint, val: boolean): void {
24496 if(!isWasmInitialized) {
24497 throw new Error("initializeWasm() must be awaited first!");
24499 const nativeResponseValue = wasm.TS_UserConfig_set_accept_mpp_keysend(this_ptr, val);
24500 // debug statements here
24502 // 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, bool accept_mpp_keysend_arg);
24504 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, accept_mpp_keysend_arg: boolean): bigint {
24505 if(!isWasmInitialized) {
24506 throw new Error("initializeWasm() must be awaited first!");
24508 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, accept_mpp_keysend_arg);
24509 return nativeResponseValue;
24511 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
24513 export function UserConfig_clone_ptr(arg: bigint): bigint {
24514 if(!isWasmInitialized) {
24515 throw new Error("initializeWasm() must be awaited first!");
24517 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
24518 return nativeResponseValue;
24520 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
24522 export function UserConfig_clone(orig: bigint): bigint {
24523 if(!isWasmInitialized) {
24524 throw new Error("initializeWasm() must be awaited first!");
24526 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
24527 return nativeResponseValue;
24529 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
24531 export function UserConfig_default(): bigint {
24532 if(!isWasmInitialized) {
24533 throw new Error("initializeWasm() must be awaited first!");
24535 const nativeResponseValue = wasm.TS_UserConfig_default();
24536 return nativeResponseValue;
24538 // void BestBlock_free(struct LDKBestBlock this_obj);
24540 export function BestBlock_free(this_obj: bigint): void {
24541 if(!isWasmInitialized) {
24542 throw new Error("initializeWasm() must be awaited first!");
24544 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
24545 // debug statements here
24547 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
24549 export function BestBlock_clone_ptr(arg: bigint): bigint {
24550 if(!isWasmInitialized) {
24551 throw new Error("initializeWasm() must be awaited first!");
24553 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
24554 return nativeResponseValue;
24556 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
24558 export function BestBlock_clone(orig: bigint): bigint {
24559 if(!isWasmInitialized) {
24560 throw new Error("initializeWasm() must be awaited first!");
24562 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
24563 return nativeResponseValue;
24565 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
24567 export function BestBlock_eq(a: bigint, b: bigint): boolean {
24568 if(!isWasmInitialized) {
24569 throw new Error("initializeWasm() must be awaited first!");
24571 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
24572 return nativeResponseValue;
24574 // MUST_USE_RES struct LDKBestBlock BestBlock_from_network(enum LDKNetwork network);
24576 export function BestBlock_from_network(network: Network): bigint {
24577 if(!isWasmInitialized) {
24578 throw new Error("initializeWasm() must be awaited first!");
24580 const nativeResponseValue = wasm.TS_BestBlock_from_network(network);
24581 return nativeResponseValue;
24583 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
24585 export function BestBlock_new(block_hash: number, height: number): bigint {
24586 if(!isWasmInitialized) {
24587 throw new Error("initializeWasm() must be awaited first!");
24589 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
24590 return nativeResponseValue;
24592 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
24594 export function BestBlock_block_hash(this_arg: bigint): number {
24595 if(!isWasmInitialized) {
24596 throw new Error("initializeWasm() must be awaited first!");
24598 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
24599 return nativeResponseValue;
24601 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
24603 export function BestBlock_height(this_arg: bigint): number {
24604 if(!isWasmInitialized) {
24605 throw new Error("initializeWasm() must be awaited first!");
24607 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
24608 return nativeResponseValue;
24610 // void Listen_free(struct LDKListen this_ptr);
24612 export function Listen_free(this_ptr: bigint): void {
24613 if(!isWasmInitialized) {
24614 throw new Error("initializeWasm() must be awaited first!");
24616 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
24617 // debug statements here
24619 // void Confirm_free(struct LDKConfirm this_ptr);
24621 export function Confirm_free(this_ptr: bigint): void {
24622 if(!isWasmInitialized) {
24623 throw new Error("initializeWasm() must be awaited first!");
24625 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
24626 // debug statements here
24628 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
24630 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
24631 if(!isWasmInitialized) {
24632 throw new Error("initializeWasm() must be awaited first!");
24634 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
24635 return nativeResponseValue;
24637 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
24639 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
24640 if(!isWasmInitialized) {
24641 throw new Error("initializeWasm() must be awaited first!");
24643 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
24644 return nativeResponseValue;
24646 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
24648 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
24649 if(!isWasmInitialized) {
24650 throw new Error("initializeWasm() must be awaited first!");
24652 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
24653 return nativeResponseValue;
24655 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_permanent_failure(void);
24657 export function ChannelMonitorUpdateStatus_permanent_failure(): ChannelMonitorUpdateStatus {
24658 if(!isWasmInitialized) {
24659 throw new Error("initializeWasm() must be awaited first!");
24661 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_permanent_failure();
24662 return nativeResponseValue;
24664 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
24666 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
24667 if(!isWasmInitialized) {
24668 throw new Error("initializeWasm() must be awaited first!");
24670 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
24671 return nativeResponseValue;
24673 // void Watch_free(struct LDKWatch this_ptr);
24675 export function Watch_free(this_ptr: bigint): void {
24676 if(!isWasmInitialized) {
24677 throw new Error("initializeWasm() must be awaited first!");
24679 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
24680 // debug statements here
24682 // void Filter_free(struct LDKFilter this_ptr);
24684 export function Filter_free(this_ptr: bigint): void {
24685 if(!isWasmInitialized) {
24686 throw new Error("initializeWasm() must be awaited first!");
24688 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
24689 // debug statements here
24691 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
24693 export function WatchedOutput_free(this_obj: bigint): void {
24694 if(!isWasmInitialized) {
24695 throw new Error("initializeWasm() must be awaited first!");
24697 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
24698 // debug statements here
24700 // struct LDKCOption_BlockHashZ WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
24702 export function WatchedOutput_get_block_hash(this_ptr: bigint): bigint {
24703 if(!isWasmInitialized) {
24704 throw new Error("initializeWasm() must be awaited first!");
24706 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
24707 return nativeResponseValue;
24709 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCOption_BlockHashZ val);
24711 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: bigint): void {
24712 if(!isWasmInitialized) {
24713 throw new Error("initializeWasm() must be awaited first!");
24715 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
24716 // debug statements here
24718 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
24720 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
24721 if(!isWasmInitialized) {
24722 throw new Error("initializeWasm() must be awaited first!");
24724 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
24725 return nativeResponseValue;
24727 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
24729 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
24730 if(!isWasmInitialized) {
24731 throw new Error("initializeWasm() must be awaited first!");
24733 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
24734 // debug statements here
24736 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
24738 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
24739 if(!isWasmInitialized) {
24740 throw new Error("initializeWasm() must be awaited first!");
24742 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
24743 return nativeResponseValue;
24745 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
24747 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
24748 if(!isWasmInitialized) {
24749 throw new Error("initializeWasm() must be awaited first!");
24751 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
24752 // debug statements here
24754 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKCOption_BlockHashZ block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
24756 export function WatchedOutput_new(block_hash_arg: bigint, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
24757 if(!isWasmInitialized) {
24758 throw new Error("initializeWasm() must be awaited first!");
24760 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
24761 return nativeResponseValue;
24763 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
24765 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
24766 if(!isWasmInitialized) {
24767 throw new Error("initializeWasm() must be awaited first!");
24769 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
24770 return nativeResponseValue;
24772 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
24774 export function WatchedOutput_clone(orig: bigint): bigint {
24775 if(!isWasmInitialized) {
24776 throw new Error("initializeWasm() must be awaited first!");
24778 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
24779 return nativeResponseValue;
24781 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
24783 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
24784 if(!isWasmInitialized) {
24785 throw new Error("initializeWasm() must be awaited first!");
24787 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
24788 return nativeResponseValue;
24790 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
24792 export function WatchedOutput_hash(o: bigint): bigint {
24793 if(!isWasmInitialized) {
24794 throw new Error("initializeWasm() must be awaited first!");
24796 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
24797 return nativeResponseValue;
24799 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
24801 export function BroadcasterInterface_free(this_ptr: bigint): void {
24802 if(!isWasmInitialized) {
24803 throw new Error("initializeWasm() must be awaited first!");
24805 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
24806 // debug statements here
24808 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
24810 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
24811 if(!isWasmInitialized) {
24812 throw new Error("initializeWasm() must be awaited first!");
24814 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
24815 return nativeResponseValue;
24817 // enum LDKConfirmationTarget ConfirmationTarget_mempool_minimum(void);
24819 export function ConfirmationTarget_mempool_minimum(): ConfirmationTarget {
24820 if(!isWasmInitialized) {
24821 throw new Error("initializeWasm() must be awaited first!");
24823 const nativeResponseValue = wasm.TS_ConfirmationTarget_mempool_minimum();
24824 return nativeResponseValue;
24826 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
24828 export function ConfirmationTarget_background(): ConfirmationTarget {
24829 if(!isWasmInitialized) {
24830 throw new Error("initializeWasm() must be awaited first!");
24832 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
24833 return nativeResponseValue;
24835 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
24837 export function ConfirmationTarget_normal(): ConfirmationTarget {
24838 if(!isWasmInitialized) {
24839 throw new Error("initializeWasm() must be awaited first!");
24841 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
24842 return nativeResponseValue;
24844 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
24846 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
24847 if(!isWasmInitialized) {
24848 throw new Error("initializeWasm() must be awaited first!");
24850 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
24851 return nativeResponseValue;
24853 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
24855 export function ConfirmationTarget_hash(o: bigint): bigint {
24856 if(!isWasmInitialized) {
24857 throw new Error("initializeWasm() must be awaited first!");
24859 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
24860 return nativeResponseValue;
24862 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
24864 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
24865 if(!isWasmInitialized) {
24866 throw new Error("initializeWasm() must be awaited first!");
24868 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
24869 return nativeResponseValue;
24871 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
24873 export function FeeEstimator_free(this_ptr: bigint): void {
24874 if(!isWasmInitialized) {
24875 throw new Error("initializeWasm() must be awaited first!");
24877 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
24878 // debug statements here
24880 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
24882 export function MonitorUpdateId_free(this_obj: bigint): void {
24883 if(!isWasmInitialized) {
24884 throw new Error("initializeWasm() must be awaited first!");
24886 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
24887 // debug statements here
24889 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
24891 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
24892 if(!isWasmInitialized) {
24893 throw new Error("initializeWasm() must be awaited first!");
24895 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
24896 return nativeResponseValue;
24898 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
24900 export function MonitorUpdateId_clone(orig: bigint): bigint {
24901 if(!isWasmInitialized) {
24902 throw new Error("initializeWasm() must be awaited first!");
24904 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
24905 return nativeResponseValue;
24907 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
24909 export function MonitorUpdateId_hash(o: bigint): bigint {
24910 if(!isWasmInitialized) {
24911 throw new Error("initializeWasm() must be awaited first!");
24913 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
24914 return nativeResponseValue;
24916 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
24918 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
24919 if(!isWasmInitialized) {
24920 throw new Error("initializeWasm() must be awaited first!");
24922 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
24923 return nativeResponseValue;
24925 // void Persist_free(struct LDKPersist this_ptr);
24927 export function Persist_free(this_ptr: bigint): void {
24928 if(!isWasmInitialized) {
24929 throw new Error("initializeWasm() must be awaited first!");
24931 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
24932 // debug statements here
24934 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
24936 export function LockedChannelMonitor_free(this_obj: bigint): void {
24937 if(!isWasmInitialized) {
24938 throw new Error("initializeWasm() must be awaited first!");
24940 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
24941 // debug statements here
24943 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
24945 export function ChainMonitor_free(this_obj: bigint): void {
24946 if(!isWasmInitialized) {
24947 throw new Error("initializeWasm() must be awaited first!");
24949 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
24950 // debug statements here
24952 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
24954 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
24955 if(!isWasmInitialized) {
24956 throw new Error("initializeWasm() must be awaited first!");
24958 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
24959 return nativeResponseValue;
24961 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
24963 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
24964 if(!isWasmInitialized) {
24965 throw new Error("initializeWasm() must be awaited first!");
24967 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
24968 return nativeResponseValue;
24970 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
24972 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
24973 if(!isWasmInitialized) {
24974 throw new Error("initializeWasm() must be awaited first!");
24976 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
24977 return nativeResponseValue;
24979 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
24981 export function ChainMonitor_list_monitors(this_arg: bigint): number {
24982 if(!isWasmInitialized) {
24983 throw new Error("initializeWasm() must be awaited first!");
24985 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
24986 return nativeResponseValue;
24988 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
24990 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
24991 if(!isWasmInitialized) {
24992 throw new Error("initializeWasm() must be awaited first!");
24994 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
24995 return nativeResponseValue;
24997 // 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);
24999 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
25000 if(!isWasmInitialized) {
25001 throw new Error("initializeWasm() must be awaited first!");
25003 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
25004 return nativeResponseValue;
25006 // MUST_USE_RES struct LDKFuture ChainMonitor_get_update_future(const struct LDKChainMonitor *NONNULL_PTR this_arg);
25008 export function ChainMonitor_get_update_future(this_arg: bigint): bigint {
25009 if(!isWasmInitialized) {
25010 throw new Error("initializeWasm() must be awaited first!");
25012 const nativeResponseValue = wasm.TS_ChainMonitor_get_update_future(this_arg);
25013 return nativeResponseValue;
25015 // void ChainMonitor_rebroadcast_pending_claims(const struct LDKChainMonitor *NONNULL_PTR this_arg);
25017 export function ChainMonitor_rebroadcast_pending_claims(this_arg: bigint): void {
25018 if(!isWasmInitialized) {
25019 throw new Error("initializeWasm() must be awaited first!");
25021 const nativeResponseValue = wasm.TS_ChainMonitor_rebroadcast_pending_claims(this_arg);
25022 // debug statements here
25024 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
25026 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
25027 if(!isWasmInitialized) {
25028 throw new Error("initializeWasm() must be awaited first!");
25030 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
25031 return nativeResponseValue;
25033 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
25035 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
25036 if(!isWasmInitialized) {
25037 throw new Error("initializeWasm() must be awaited first!");
25039 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
25040 return nativeResponseValue;
25042 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
25044 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
25045 if(!isWasmInitialized) {
25046 throw new Error("initializeWasm() must be awaited first!");
25048 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
25049 return nativeResponseValue;
25051 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
25053 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
25054 if(!isWasmInitialized) {
25055 throw new Error("initializeWasm() must be awaited first!");
25057 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
25058 return nativeResponseValue;
25060 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
25062 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
25063 if(!isWasmInitialized) {
25064 throw new Error("initializeWasm() must be awaited first!");
25066 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
25067 // debug statements here
25069 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
25071 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
25072 if(!isWasmInitialized) {
25073 throw new Error("initializeWasm() must be awaited first!");
25075 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
25076 return nativeResponseValue;
25078 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
25080 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
25081 if(!isWasmInitialized) {
25082 throw new Error("initializeWasm() must be awaited first!");
25084 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
25085 // debug statements here
25087 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
25089 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
25090 if(!isWasmInitialized) {
25091 throw new Error("initializeWasm() must be awaited first!");
25093 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
25094 return nativeResponseValue;
25096 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
25098 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
25099 if(!isWasmInitialized) {
25100 throw new Error("initializeWasm() must be awaited first!");
25102 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
25103 return nativeResponseValue;
25105 // bool ChannelMonitorUpdate_eq(const struct LDKChannelMonitorUpdate *NONNULL_PTR a, const struct LDKChannelMonitorUpdate *NONNULL_PTR b);
25107 export function ChannelMonitorUpdate_eq(a: bigint, b: bigint): boolean {
25108 if(!isWasmInitialized) {
25109 throw new Error("initializeWasm() must be awaited first!");
25111 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_eq(a, b);
25112 return nativeResponseValue;
25114 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
25116 export function ChannelMonitorUpdate_write(obj: bigint): number {
25117 if(!isWasmInitialized) {
25118 throw new Error("initializeWasm() must be awaited first!");
25120 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
25121 return nativeResponseValue;
25123 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
25125 export function ChannelMonitorUpdate_read(ser: number): bigint {
25126 if(!isWasmInitialized) {
25127 throw new Error("initializeWasm() must be awaited first!");
25129 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
25130 return nativeResponseValue;
25132 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
25134 export function MonitorEvent_free(this_ptr: bigint): void {
25135 if(!isWasmInitialized) {
25136 throw new Error("initializeWasm() must be awaited first!");
25138 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
25139 // debug statements here
25141 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
25143 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
25144 if(!isWasmInitialized) {
25145 throw new Error("initializeWasm() must be awaited first!");
25147 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
25148 return nativeResponseValue;
25150 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
25152 export function MonitorEvent_clone(orig: bigint): bigint {
25153 if(!isWasmInitialized) {
25154 throw new Error("initializeWasm() must be awaited first!");
25156 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
25157 return nativeResponseValue;
25159 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
25161 export function MonitorEvent_htlcevent(a: bigint): bigint {
25162 if(!isWasmInitialized) {
25163 throw new Error("initializeWasm() must be awaited first!");
25165 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
25166 return nativeResponseValue;
25168 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
25170 export function MonitorEvent_commitment_tx_confirmed(a: bigint): bigint {
25171 if(!isWasmInitialized) {
25172 throw new Error("initializeWasm() must be awaited first!");
25174 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
25175 return nativeResponseValue;
25177 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
25179 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
25180 if(!isWasmInitialized) {
25181 throw new Error("initializeWasm() must be awaited first!");
25183 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
25184 return nativeResponseValue;
25186 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
25188 export function MonitorEvent_update_failed(a: bigint): bigint {
25189 if(!isWasmInitialized) {
25190 throw new Error("initializeWasm() must be awaited first!");
25192 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
25193 return nativeResponseValue;
25195 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
25197 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
25198 if(!isWasmInitialized) {
25199 throw new Error("initializeWasm() must be awaited first!");
25201 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
25202 return nativeResponseValue;
25204 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
25206 export function MonitorEvent_write(obj: bigint): number {
25207 if(!isWasmInitialized) {
25208 throw new Error("initializeWasm() must be awaited first!");
25210 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
25211 return nativeResponseValue;
25213 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
25215 export function MonitorEvent_read(ser: number): bigint {
25216 if(!isWasmInitialized) {
25217 throw new Error("initializeWasm() must be awaited first!");
25219 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
25220 return nativeResponseValue;
25222 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
25224 export function HTLCUpdate_free(this_obj: bigint): void {
25225 if(!isWasmInitialized) {
25226 throw new Error("initializeWasm() must be awaited first!");
25228 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
25229 // debug statements here
25231 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
25233 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
25234 if(!isWasmInitialized) {
25235 throw new Error("initializeWasm() must be awaited first!");
25237 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
25238 return nativeResponseValue;
25240 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
25242 export function HTLCUpdate_clone(orig: bigint): bigint {
25243 if(!isWasmInitialized) {
25244 throw new Error("initializeWasm() must be awaited first!");
25246 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
25247 return nativeResponseValue;
25249 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
25251 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
25252 if(!isWasmInitialized) {
25253 throw new Error("initializeWasm() must be awaited first!");
25255 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
25256 return nativeResponseValue;
25258 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
25260 export function HTLCUpdate_write(obj: bigint): number {
25261 if(!isWasmInitialized) {
25262 throw new Error("initializeWasm() must be awaited first!");
25264 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
25265 return nativeResponseValue;
25267 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
25269 export function HTLCUpdate_read(ser: number): bigint {
25270 if(!isWasmInitialized) {
25271 throw new Error("initializeWasm() must be awaited first!");
25273 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
25274 return nativeResponseValue;
25276 // void Balance_free(struct LDKBalance this_ptr);
25278 export function Balance_free(this_ptr: bigint): void {
25279 if(!isWasmInitialized) {
25280 throw new Error("initializeWasm() must be awaited first!");
25282 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
25283 // debug statements here
25285 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
25287 export function Balance_clone_ptr(arg: bigint): bigint {
25288 if(!isWasmInitialized) {
25289 throw new Error("initializeWasm() must be awaited first!");
25291 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
25292 return nativeResponseValue;
25294 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
25296 export function Balance_clone(orig: bigint): bigint {
25297 if(!isWasmInitialized) {
25298 throw new Error("initializeWasm() must be awaited first!");
25300 const nativeResponseValue = wasm.TS_Balance_clone(orig);
25301 return nativeResponseValue;
25303 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t amount_satoshis);
25305 export function Balance_claimable_on_channel_close(amount_satoshis: bigint): bigint {
25306 if(!isWasmInitialized) {
25307 throw new Error("initializeWasm() must be awaited first!");
25309 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(amount_satoshis);
25310 return nativeResponseValue;
25312 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t amount_satoshis, uint32_t confirmation_height);
25314 export function Balance_claimable_awaiting_confirmations(amount_satoshis: bigint, confirmation_height: number): bigint {
25315 if(!isWasmInitialized) {
25316 throw new Error("initializeWasm() must be awaited first!");
25318 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(amount_satoshis, confirmation_height);
25319 return nativeResponseValue;
25321 // struct LDKBalance Balance_contentious_claimable(uint64_t amount_satoshis, uint32_t timeout_height, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_preimage);
25323 export function Balance_contentious_claimable(amount_satoshis: bigint, timeout_height: number, payment_hash: number, payment_preimage: number): bigint {
25324 if(!isWasmInitialized) {
25325 throw new Error("initializeWasm() must be awaited first!");
25327 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(amount_satoshis, timeout_height, payment_hash, payment_preimage);
25328 return nativeResponseValue;
25330 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t amount_satoshis, uint32_t claimable_height, struct LDKThirtyTwoBytes payment_hash);
25332 export function Balance_maybe_timeout_claimable_htlc(amount_satoshis: bigint, claimable_height: number, payment_hash: number): bigint {
25333 if(!isWasmInitialized) {
25334 throw new Error("initializeWasm() must be awaited first!");
25336 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(amount_satoshis, claimable_height, payment_hash);
25337 return nativeResponseValue;
25339 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t amount_satoshis, uint32_t expiry_height, struct LDKThirtyTwoBytes payment_hash);
25341 export function Balance_maybe_preimage_claimable_htlc(amount_satoshis: bigint, expiry_height: number, payment_hash: number): bigint {
25342 if(!isWasmInitialized) {
25343 throw new Error("initializeWasm() must be awaited first!");
25345 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(amount_satoshis, expiry_height, payment_hash);
25346 return nativeResponseValue;
25348 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t amount_satoshis);
25350 export function Balance_counterparty_revoked_output_claimable(amount_satoshis: bigint): bigint {
25351 if(!isWasmInitialized) {
25352 throw new Error("initializeWasm() must be awaited first!");
25354 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(amount_satoshis);
25355 return nativeResponseValue;
25357 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
25359 export function Balance_eq(a: bigint, b: bigint): boolean {
25360 if(!isWasmInitialized) {
25361 throw new Error("initializeWasm() must be awaited first!");
25363 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
25364 return nativeResponseValue;
25366 // MUST_USE_RES uint64_t Balance_claimable_amount_satoshis(const struct LDKBalance *NONNULL_PTR this_arg);
25368 export function Balance_claimable_amount_satoshis(this_arg: bigint): bigint {
25369 if(!isWasmInitialized) {
25370 throw new Error("initializeWasm() must be awaited first!");
25372 const nativeResponseValue = wasm.TS_Balance_claimable_amount_satoshis(this_arg);
25373 return nativeResponseValue;
25375 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
25377 export function ChannelMonitor_free(this_obj: bigint): void {
25378 if(!isWasmInitialized) {
25379 throw new Error("initializeWasm() must be awaited first!");
25381 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
25382 // debug statements here
25384 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
25386 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
25387 if(!isWasmInitialized) {
25388 throw new Error("initializeWasm() must be awaited first!");
25390 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
25391 return nativeResponseValue;
25393 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
25395 export function ChannelMonitor_clone(orig: bigint): bigint {
25396 if(!isWasmInitialized) {
25397 throw new Error("initializeWasm() must be awaited first!");
25399 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
25400 return nativeResponseValue;
25402 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
25404 export function ChannelMonitor_write(obj: bigint): number {
25405 if(!isWasmInitialized) {
25406 throw new Error("initializeWasm() must be awaited first!");
25408 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
25409 return nativeResponseValue;
25411 // 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);
25413 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
25414 if(!isWasmInitialized) {
25415 throw new Error("initializeWasm() must be awaited first!");
25417 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
25418 return nativeResponseValue;
25420 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25422 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
25423 if(!isWasmInitialized) {
25424 throw new Error("initializeWasm() must be awaited first!");
25426 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
25427 return nativeResponseValue;
25429 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25431 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
25432 if(!isWasmInitialized) {
25433 throw new Error("initializeWasm() must be awaited first!");
25435 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
25436 return nativeResponseValue;
25438 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25440 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
25441 if(!isWasmInitialized) {
25442 throw new Error("initializeWasm() must be awaited first!");
25444 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
25445 return nativeResponseValue;
25447 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
25449 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
25450 if(!isWasmInitialized) {
25451 throw new Error("initializeWasm() must be awaited first!");
25453 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
25454 // debug statements here
25456 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25458 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
25459 if(!isWasmInitialized) {
25460 throw new Error("initializeWasm() must be awaited first!");
25462 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
25463 return nativeResponseValue;
25465 // void ChannelMonitor_process_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKEventHandler *NONNULL_PTR handler);
25467 export function ChannelMonitor_process_pending_events(this_arg: bigint, handler: bigint): void {
25468 if(!isWasmInitialized) {
25469 throw new Error("initializeWasm() must be awaited first!");
25471 const nativeResponseValue = wasm.TS_ChannelMonitor_process_pending_events(this_arg, handler);
25472 // debug statements here
25474 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25476 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
25477 if(!isWasmInitialized) {
25478 throw new Error("initializeWasm() must be awaited first!");
25480 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
25481 return nativeResponseValue;
25483 // 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);
25485 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
25486 if(!isWasmInitialized) {
25487 throw new Error("initializeWasm() must be awaited first!");
25489 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
25490 return nativeResponseValue;
25492 // 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);
25494 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
25495 if(!isWasmInitialized) {
25496 throw new Error("initializeWasm() must be awaited first!");
25498 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
25499 return nativeResponseValue;
25501 // 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);
25503 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
25504 if(!isWasmInitialized) {
25505 throw new Error("initializeWasm() must be awaited first!");
25507 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
25508 // debug statements here
25510 // 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);
25512 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
25513 if(!isWasmInitialized) {
25514 throw new Error("initializeWasm() must be awaited first!");
25516 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
25517 return nativeResponseValue;
25519 // 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);
25521 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
25522 if(!isWasmInitialized) {
25523 throw new Error("initializeWasm() must be awaited first!");
25525 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
25526 // debug statements here
25528 // 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);
25530 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
25531 if(!isWasmInitialized) {
25532 throw new Error("initializeWasm() must be awaited first!");
25534 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
25535 return nativeResponseValue;
25537 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCOption_BlockHashZZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25539 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
25540 if(!isWasmInitialized) {
25541 throw new Error("initializeWasm() must be awaited first!");
25543 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
25544 return nativeResponseValue;
25546 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25548 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
25549 if(!isWasmInitialized) {
25550 throw new Error("initializeWasm() must be awaited first!");
25552 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
25553 return nativeResponseValue;
25555 // void ChannelMonitor_rebroadcast_pending_claims(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
25557 export function ChannelMonitor_rebroadcast_pending_claims(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
25558 if(!isWasmInitialized) {
25559 throw new Error("initializeWasm() must be awaited first!");
25561 const nativeResponseValue = wasm.TS_ChannelMonitor_rebroadcast_pending_claims(this_arg, broadcaster, fee_estimator, logger);
25562 // debug statements here
25564 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
25566 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
25567 if(!isWasmInitialized) {
25568 throw new Error("initializeWasm() must be awaited first!");
25570 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
25571 return nativeResponseValue;
25573 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKEntropySource *NONNULL_PTR arg_a, const struct LDKSignerProvider *NONNULL_PTR arg_b);
25575 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
25576 if(!isWasmInitialized) {
25577 throw new Error("initializeWasm() must be awaited first!");
25579 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg_a, arg_b);
25580 return nativeResponseValue;
25582 // void OutPoint_free(struct LDKOutPoint this_obj);
25584 export function OutPoint_free(this_obj: bigint): void {
25585 if(!isWasmInitialized) {
25586 throw new Error("initializeWasm() must be awaited first!");
25588 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
25589 // debug statements here
25591 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
25593 export function OutPoint_get_txid(this_ptr: bigint): number {
25594 if(!isWasmInitialized) {
25595 throw new Error("initializeWasm() must be awaited first!");
25597 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
25598 return nativeResponseValue;
25600 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25602 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
25603 if(!isWasmInitialized) {
25604 throw new Error("initializeWasm() must be awaited first!");
25606 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
25607 // debug statements here
25609 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
25611 export function OutPoint_get_index(this_ptr: bigint): number {
25612 if(!isWasmInitialized) {
25613 throw new Error("initializeWasm() must be awaited first!");
25615 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
25616 return nativeResponseValue;
25618 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
25620 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
25621 if(!isWasmInitialized) {
25622 throw new Error("initializeWasm() must be awaited first!");
25624 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
25625 // debug statements here
25627 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
25629 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
25630 if(!isWasmInitialized) {
25631 throw new Error("initializeWasm() must be awaited first!");
25633 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
25634 return nativeResponseValue;
25636 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
25638 export function OutPoint_clone_ptr(arg: bigint): bigint {
25639 if(!isWasmInitialized) {
25640 throw new Error("initializeWasm() must be awaited first!");
25642 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
25643 return nativeResponseValue;
25645 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
25647 export function OutPoint_clone(orig: bigint): bigint {
25648 if(!isWasmInitialized) {
25649 throw new Error("initializeWasm() must be awaited first!");
25651 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
25652 return nativeResponseValue;
25654 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
25656 export function OutPoint_eq(a: bigint, b: bigint): boolean {
25657 if(!isWasmInitialized) {
25658 throw new Error("initializeWasm() must be awaited first!");
25660 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
25661 return nativeResponseValue;
25663 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
25665 export function OutPoint_hash(o: bigint): bigint {
25666 if(!isWasmInitialized) {
25667 throw new Error("initializeWasm() must be awaited first!");
25669 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
25670 return nativeResponseValue;
25672 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
25674 export function OutPoint_to_channel_id(this_arg: bigint): number {
25675 if(!isWasmInitialized) {
25676 throw new Error("initializeWasm() must be awaited first!");
25678 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
25679 return nativeResponseValue;
25681 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
25683 export function OutPoint_write(obj: bigint): number {
25684 if(!isWasmInitialized) {
25685 throw new Error("initializeWasm() must be awaited first!");
25687 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
25688 return nativeResponseValue;
25690 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
25692 export function OutPoint_read(ser: number): bigint {
25693 if(!isWasmInitialized) {
25694 throw new Error("initializeWasm() must be awaited first!");
25696 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
25697 return nativeResponseValue;
25699 // enum LDKFailureCode FailureCode_clone(const enum LDKFailureCode *NONNULL_PTR orig);
25701 export function FailureCode_clone(orig: bigint): FailureCode {
25702 if(!isWasmInitialized) {
25703 throw new Error("initializeWasm() must be awaited first!");
25705 const nativeResponseValue = wasm.TS_FailureCode_clone(orig);
25706 return nativeResponseValue;
25708 // enum LDKFailureCode FailureCode_temporary_node_failure(void);
25710 export function FailureCode_temporary_node_failure(): FailureCode {
25711 if(!isWasmInitialized) {
25712 throw new Error("initializeWasm() must be awaited first!");
25714 const nativeResponseValue = wasm.TS_FailureCode_temporary_node_failure();
25715 return nativeResponseValue;
25717 // enum LDKFailureCode FailureCode_required_node_feature_missing(void);
25719 export function FailureCode_required_node_feature_missing(): FailureCode {
25720 if(!isWasmInitialized) {
25721 throw new Error("initializeWasm() must be awaited first!");
25723 const nativeResponseValue = wasm.TS_FailureCode_required_node_feature_missing();
25724 return nativeResponseValue;
25726 // enum LDKFailureCode FailureCode_incorrect_or_unknown_payment_details(void);
25728 export function FailureCode_incorrect_or_unknown_payment_details(): FailureCode {
25729 if(!isWasmInitialized) {
25730 throw new Error("initializeWasm() must be awaited first!");
25732 const nativeResponseValue = wasm.TS_FailureCode_incorrect_or_unknown_payment_details();
25733 return nativeResponseValue;
25735 // void ChannelManager_free(struct LDKChannelManager this_obj);
25737 export function ChannelManager_free(this_obj: bigint): void {
25738 if(!isWasmInitialized) {
25739 throw new Error("initializeWasm() must be awaited first!");
25741 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
25742 // debug statements here
25744 // void ChainParameters_free(struct LDKChainParameters this_obj);
25746 export function ChainParameters_free(this_obj: bigint): void {
25747 if(!isWasmInitialized) {
25748 throw new Error("initializeWasm() must be awaited first!");
25750 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
25751 // debug statements here
25753 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
25755 export function ChainParameters_get_network(this_ptr: bigint): Network {
25756 if(!isWasmInitialized) {
25757 throw new Error("initializeWasm() must be awaited first!");
25759 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
25760 return nativeResponseValue;
25762 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
25764 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
25765 if(!isWasmInitialized) {
25766 throw new Error("initializeWasm() must be awaited first!");
25768 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
25769 // debug statements here
25771 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
25773 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
25774 if(!isWasmInitialized) {
25775 throw new Error("initializeWasm() must be awaited first!");
25777 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
25778 return nativeResponseValue;
25780 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
25782 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
25783 if(!isWasmInitialized) {
25784 throw new Error("initializeWasm() must be awaited first!");
25786 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
25787 // debug statements here
25789 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
25791 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
25792 if(!isWasmInitialized) {
25793 throw new Error("initializeWasm() must be awaited first!");
25795 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
25796 return nativeResponseValue;
25798 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
25800 export function ChainParameters_clone_ptr(arg: bigint): bigint {
25801 if(!isWasmInitialized) {
25802 throw new Error("initializeWasm() must be awaited first!");
25804 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
25805 return nativeResponseValue;
25807 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
25809 export function ChainParameters_clone(orig: bigint): bigint {
25810 if(!isWasmInitialized) {
25811 throw new Error("initializeWasm() must be awaited first!");
25813 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
25814 return nativeResponseValue;
25816 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
25818 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
25819 if(!isWasmInitialized) {
25820 throw new Error("initializeWasm() must be awaited first!");
25822 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
25823 // debug statements here
25825 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
25827 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
25828 if(!isWasmInitialized) {
25829 throw new Error("initializeWasm() must be awaited first!");
25831 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
25832 return nativeResponseValue;
25834 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
25836 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
25837 if(!isWasmInitialized) {
25838 throw new Error("initializeWasm() must be awaited first!");
25840 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
25841 // debug statements here
25843 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
25845 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
25846 if(!isWasmInitialized) {
25847 throw new Error("initializeWasm() must be awaited first!");
25849 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
25850 return nativeResponseValue;
25852 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
25854 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
25855 if(!isWasmInitialized) {
25856 throw new Error("initializeWasm() must be awaited first!");
25858 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
25859 // debug statements here
25861 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
25863 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
25864 if(!isWasmInitialized) {
25865 throw new Error("initializeWasm() must be awaited first!");
25867 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
25868 return nativeResponseValue;
25870 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
25872 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
25873 if(!isWasmInitialized) {
25874 throw new Error("initializeWasm() must be awaited first!");
25876 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
25877 // debug statements here
25879 // 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);
25881 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
25882 if(!isWasmInitialized) {
25883 throw new Error("initializeWasm() must be awaited first!");
25885 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
25886 return nativeResponseValue;
25888 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
25890 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
25891 if(!isWasmInitialized) {
25892 throw new Error("initializeWasm() must be awaited first!");
25894 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
25895 return nativeResponseValue;
25897 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
25899 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
25900 if(!isWasmInitialized) {
25901 throw new Error("initializeWasm() must be awaited first!");
25903 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
25904 return nativeResponseValue;
25906 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
25908 export function ChannelCounterparty_free(this_obj: bigint): void {
25909 if(!isWasmInitialized) {
25910 throw new Error("initializeWasm() must be awaited first!");
25912 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
25913 // debug statements here
25915 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
25917 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
25918 if(!isWasmInitialized) {
25919 throw new Error("initializeWasm() must be awaited first!");
25921 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
25922 return nativeResponseValue;
25924 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25926 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
25927 if(!isWasmInitialized) {
25928 throw new Error("initializeWasm() must be awaited first!");
25930 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
25931 // debug statements here
25933 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
25935 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
25936 if(!isWasmInitialized) {
25937 throw new Error("initializeWasm() must be awaited first!");
25939 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
25940 return nativeResponseValue;
25942 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
25944 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
25945 if(!isWasmInitialized) {
25946 throw new Error("initializeWasm() must be awaited first!");
25948 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
25949 // debug statements here
25951 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
25953 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
25954 if(!isWasmInitialized) {
25955 throw new Error("initializeWasm() must be awaited first!");
25957 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
25958 return nativeResponseValue;
25960 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
25962 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
25963 if(!isWasmInitialized) {
25964 throw new Error("initializeWasm() must be awaited first!");
25966 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
25967 // debug statements here
25969 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
25971 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
25972 if(!isWasmInitialized) {
25973 throw new Error("initializeWasm() must be awaited first!");
25975 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
25976 return nativeResponseValue;
25978 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
25980 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
25981 if(!isWasmInitialized) {
25982 throw new Error("initializeWasm() must be awaited first!");
25984 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
25985 // debug statements here
25987 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
25989 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
25990 if(!isWasmInitialized) {
25991 throw new Error("initializeWasm() must be awaited first!");
25993 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
25994 return nativeResponseValue;
25996 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25998 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
25999 if(!isWasmInitialized) {
26000 throw new Error("initializeWasm() must be awaited first!");
26002 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
26003 // debug statements here
26005 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
26007 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
26008 if(!isWasmInitialized) {
26009 throw new Error("initializeWasm() must be awaited first!");
26011 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
26012 return nativeResponseValue;
26014 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26016 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
26017 if(!isWasmInitialized) {
26018 throw new Error("initializeWasm() must be awaited first!");
26020 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
26021 // debug statements here
26023 // 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);
26025 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 {
26026 if(!isWasmInitialized) {
26027 throw new Error("initializeWasm() must be awaited first!");
26029 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);
26030 return nativeResponseValue;
26032 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
26034 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
26035 if(!isWasmInitialized) {
26036 throw new Error("initializeWasm() must be awaited first!");
26038 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
26039 return nativeResponseValue;
26041 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
26043 export function ChannelCounterparty_clone(orig: bigint): bigint {
26044 if(!isWasmInitialized) {
26045 throw new Error("initializeWasm() must be awaited first!");
26047 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
26048 return nativeResponseValue;
26050 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
26052 export function ChannelDetails_free(this_obj: bigint): void {
26053 if(!isWasmInitialized) {
26054 throw new Error("initializeWasm() must be awaited first!");
26056 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
26057 // debug statements here
26059 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
26061 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
26062 if(!isWasmInitialized) {
26063 throw new Error("initializeWasm() must be awaited first!");
26065 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
26066 return nativeResponseValue;
26068 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26070 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
26071 if(!isWasmInitialized) {
26072 throw new Error("initializeWasm() must be awaited first!");
26074 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
26075 // debug statements here
26077 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26079 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
26080 if(!isWasmInitialized) {
26081 throw new Error("initializeWasm() must be awaited first!");
26083 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
26084 return nativeResponseValue;
26086 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
26088 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
26089 if(!isWasmInitialized) {
26090 throw new Error("initializeWasm() must be awaited first!");
26092 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
26093 // debug statements here
26095 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26097 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
26098 if(!isWasmInitialized) {
26099 throw new Error("initializeWasm() must be awaited first!");
26101 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
26102 return nativeResponseValue;
26104 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
26106 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
26107 if(!isWasmInitialized) {
26108 throw new Error("initializeWasm() must be awaited first!");
26110 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
26111 // debug statements here
26113 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26115 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
26116 if(!isWasmInitialized) {
26117 throw new Error("initializeWasm() must be awaited first!");
26119 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
26120 return nativeResponseValue;
26122 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
26124 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
26125 if(!isWasmInitialized) {
26126 throw new Error("initializeWasm() must be awaited first!");
26128 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
26129 // debug statements here
26131 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26133 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
26134 if(!isWasmInitialized) {
26135 throw new Error("initializeWasm() must be awaited first!");
26137 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
26138 return nativeResponseValue;
26140 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26142 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
26143 if(!isWasmInitialized) {
26144 throw new Error("initializeWasm() must be awaited first!");
26146 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
26147 // debug statements here
26149 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26151 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
26152 if(!isWasmInitialized) {
26153 throw new Error("initializeWasm() must be awaited first!");
26155 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
26156 return nativeResponseValue;
26158 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26160 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
26161 if(!isWasmInitialized) {
26162 throw new Error("initializeWasm() must be awaited first!");
26164 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
26165 // debug statements here
26167 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26169 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
26170 if(!isWasmInitialized) {
26171 throw new Error("initializeWasm() must be awaited first!");
26173 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
26174 return nativeResponseValue;
26176 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26178 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
26179 if(!isWasmInitialized) {
26180 throw new Error("initializeWasm() must be awaited first!");
26182 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
26183 // debug statements here
26185 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26187 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
26188 if(!isWasmInitialized) {
26189 throw new Error("initializeWasm() must be awaited first!");
26191 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
26192 return nativeResponseValue;
26194 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
26196 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
26197 if(!isWasmInitialized) {
26198 throw new Error("initializeWasm() must be awaited first!");
26200 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
26201 // debug statements here
26203 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26205 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
26206 if(!isWasmInitialized) {
26207 throw new Error("initializeWasm() must be awaited first!");
26209 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
26210 return nativeResponseValue;
26212 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26214 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
26215 if(!isWasmInitialized) {
26216 throw new Error("initializeWasm() must be awaited first!");
26218 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
26219 // debug statements here
26221 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26223 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
26224 if(!isWasmInitialized) {
26225 throw new Error("initializeWasm() must be awaited first!");
26227 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
26228 return nativeResponseValue;
26230 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
26232 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
26233 if(!isWasmInitialized) {
26234 throw new Error("initializeWasm() must be awaited first!");
26236 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
26237 // debug statements here
26239 // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26241 export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
26242 if(!isWasmInitialized) {
26243 throw new Error("initializeWasm() must be awaited first!");
26245 const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
26246 return nativeResponseValue;
26248 // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26250 export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
26251 if(!isWasmInitialized) {
26252 throw new Error("initializeWasm() must be awaited first!");
26254 const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
26255 // debug statements here
26257 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26259 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
26260 if(!isWasmInitialized) {
26261 throw new Error("initializeWasm() must be awaited first!");
26263 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
26264 return nativeResponseValue;
26266 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
26268 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
26269 if(!isWasmInitialized) {
26270 throw new Error("initializeWasm() must be awaited first!");
26272 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
26273 // debug statements here
26275 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26277 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
26278 if(!isWasmInitialized) {
26279 throw new Error("initializeWasm() must be awaited first!");
26281 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
26282 return nativeResponseValue;
26284 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
26286 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
26287 if(!isWasmInitialized) {
26288 throw new Error("initializeWasm() must be awaited first!");
26290 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
26291 // debug statements here
26293 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26295 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
26296 if(!isWasmInitialized) {
26297 throw new Error("initializeWasm() must be awaited first!");
26299 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
26300 return nativeResponseValue;
26302 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
26304 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
26305 if(!isWasmInitialized) {
26306 throw new Error("initializeWasm() must be awaited first!");
26308 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
26309 // debug statements here
26311 // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26313 export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
26314 if(!isWasmInitialized) {
26315 throw new Error("initializeWasm() must be awaited first!");
26317 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
26318 return nativeResponseValue;
26320 // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
26322 export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
26323 if(!isWasmInitialized) {
26324 throw new Error("initializeWasm() must be awaited first!");
26326 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
26327 // debug statements here
26329 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26331 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
26332 if(!isWasmInitialized) {
26333 throw new Error("initializeWasm() must be awaited first!");
26335 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
26336 return nativeResponseValue;
26338 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
26340 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
26341 if(!isWasmInitialized) {
26342 throw new Error("initializeWasm() must be awaited first!");
26344 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
26345 // debug statements here
26347 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26349 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
26350 if(!isWasmInitialized) {
26351 throw new Error("initializeWasm() must be awaited first!");
26353 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
26354 return nativeResponseValue;
26356 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26358 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
26359 if(!isWasmInitialized) {
26360 throw new Error("initializeWasm() must be awaited first!");
26362 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
26363 // debug statements here
26365 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26367 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
26368 if(!isWasmInitialized) {
26369 throw new Error("initializeWasm() must be awaited first!");
26371 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
26372 return nativeResponseValue;
26374 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26376 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
26377 if(!isWasmInitialized) {
26378 throw new Error("initializeWasm() must be awaited first!");
26380 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
26381 // debug statements here
26383 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26385 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
26386 if(!isWasmInitialized) {
26387 throw new Error("initializeWasm() must be awaited first!");
26389 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
26390 return nativeResponseValue;
26392 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
26394 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
26395 if(!isWasmInitialized) {
26396 throw new Error("initializeWasm() must be awaited first!");
26398 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
26399 // debug statements here
26401 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26403 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
26404 if(!isWasmInitialized) {
26405 throw new Error("initializeWasm() must be awaited first!");
26407 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
26408 return nativeResponseValue;
26410 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
26412 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
26413 if(!isWasmInitialized) {
26414 throw new Error("initializeWasm() must be awaited first!");
26416 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
26417 // debug statements here
26419 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26421 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
26422 if(!isWasmInitialized) {
26423 throw new Error("initializeWasm() must be awaited first!");
26425 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
26426 return nativeResponseValue;
26428 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
26430 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
26431 if(!isWasmInitialized) {
26432 throw new Error("initializeWasm() must be awaited first!");
26434 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
26435 // debug statements here
26437 // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26439 export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
26440 if(!isWasmInitialized) {
26441 throw new Error("initializeWasm() must be awaited first!");
26443 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
26444 return nativeResponseValue;
26446 // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
26448 export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
26449 if(!isWasmInitialized) {
26450 throw new Error("initializeWasm() must be awaited first!");
26452 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
26453 // debug statements here
26455 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26457 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
26458 if(!isWasmInitialized) {
26459 throw new Error("initializeWasm() must be awaited first!");
26461 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
26462 return nativeResponseValue;
26464 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
26466 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
26467 if(!isWasmInitialized) {
26468 throw new Error("initializeWasm() must be awaited first!");
26470 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
26471 // debug statements here
26473 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26475 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
26476 if(!isWasmInitialized) {
26477 throw new Error("initializeWasm() must be awaited first!");
26479 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
26480 return nativeResponseValue;
26482 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
26484 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
26485 if(!isWasmInitialized) {
26486 throw new Error("initializeWasm() must be awaited first!");
26488 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
26489 // debug statements here
26491 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26493 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
26494 if(!isWasmInitialized) {
26495 throw new Error("initializeWasm() must be awaited first!");
26497 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
26498 return nativeResponseValue;
26500 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26502 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
26503 if(!isWasmInitialized) {
26504 throw new Error("initializeWasm() must be awaited first!");
26506 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
26507 // debug statements here
26509 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26511 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
26512 if(!isWasmInitialized) {
26513 throw new Error("initializeWasm() must be awaited first!");
26515 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
26516 return nativeResponseValue;
26518 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26520 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
26521 if(!isWasmInitialized) {
26522 throw new Error("initializeWasm() must be awaited first!");
26524 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
26525 // debug statements here
26527 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
26529 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
26530 if(!isWasmInitialized) {
26531 throw new Error("initializeWasm() must be awaited first!");
26533 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
26534 return nativeResponseValue;
26536 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
26538 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
26539 if(!isWasmInitialized) {
26540 throw new Error("initializeWasm() must be awaited first!");
26542 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
26543 // debug statements here
26545 // 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, struct LDKCOption_u32Z feerate_sat_per_1000_weight_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t next_outbound_htlc_minimum_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, struct LDKCOption_ChannelShutdownStateZ channel_shutdown_state_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);
26547 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, feerate_sat_per_1000_weight_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, next_outbound_htlc_minimum_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, channel_shutdown_state_arg: bigint, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
26548 if(!isWasmInitialized) {
26549 throw new Error("initializeWasm() must be awaited first!");
26551 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, feerate_sat_per_1000_weight_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, next_outbound_htlc_minimum_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, confirmations_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, channel_shutdown_state_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
26552 return nativeResponseValue;
26554 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
26556 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
26557 if(!isWasmInitialized) {
26558 throw new Error("initializeWasm() must be awaited first!");
26560 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
26561 return nativeResponseValue;
26563 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
26565 export function ChannelDetails_clone(orig: bigint): bigint {
26566 if(!isWasmInitialized) {
26567 throw new Error("initializeWasm() must be awaited first!");
26569 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
26570 return nativeResponseValue;
26572 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
26574 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
26575 if(!isWasmInitialized) {
26576 throw new Error("initializeWasm() must be awaited first!");
26578 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
26579 return nativeResponseValue;
26581 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
26583 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
26584 if(!isWasmInitialized) {
26585 throw new Error("initializeWasm() must be awaited first!");
26587 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
26588 return nativeResponseValue;
26590 // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
26592 export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
26593 if(!isWasmInitialized) {
26594 throw new Error("initializeWasm() must be awaited first!");
26596 const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
26597 return nativeResponseValue;
26599 // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
26601 export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
26602 if(!isWasmInitialized) {
26603 throw new Error("initializeWasm() must be awaited first!");
26605 const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
26606 return nativeResponseValue;
26608 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
26610 export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
26611 if(!isWasmInitialized) {
26612 throw new Error("initializeWasm() must be awaited first!");
26614 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
26615 return nativeResponseValue;
26617 // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
26619 export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
26620 if(!isWasmInitialized) {
26621 throw new Error("initializeWasm() must be awaited first!");
26623 const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
26624 return nativeResponseValue;
26626 // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
26628 export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
26629 if(!isWasmInitialized) {
26630 throw new Error("initializeWasm() must be awaited first!");
26632 const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
26633 return nativeResponseValue;
26635 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
26637 export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
26638 if(!isWasmInitialized) {
26639 throw new Error("initializeWasm() must be awaited first!");
26641 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
26642 return nativeResponseValue;
26644 // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
26646 export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
26647 if(!isWasmInitialized) {
26648 throw new Error("initializeWasm() must be awaited first!");
26650 const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
26651 return nativeResponseValue;
26653 // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
26655 export function RecentPaymentDetails_free(this_ptr: bigint): void {
26656 if(!isWasmInitialized) {
26657 throw new Error("initializeWasm() must be awaited first!");
26659 const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
26660 // debug statements here
26662 // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
26664 export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
26665 if(!isWasmInitialized) {
26666 throw new Error("initializeWasm() must be awaited first!");
26668 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
26669 return nativeResponseValue;
26671 // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
26673 export function RecentPaymentDetails_clone(orig: bigint): bigint {
26674 if(!isWasmInitialized) {
26675 throw new Error("initializeWasm() must be awaited first!");
26677 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
26678 return nativeResponseValue;
26680 // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
26682 export function RecentPaymentDetails_pending(payment_hash: number, total_msat: bigint): bigint {
26683 if(!isWasmInitialized) {
26684 throw new Error("initializeWasm() must be awaited first!");
26686 const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_hash, total_msat);
26687 return nativeResponseValue;
26689 // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKCOption_PaymentHashZ payment_hash);
26691 export function RecentPaymentDetails_fulfilled(payment_hash: bigint): bigint {
26692 if(!isWasmInitialized) {
26693 throw new Error("initializeWasm() must be awaited first!");
26695 const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_hash);
26696 return nativeResponseValue;
26698 // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_hash);
26700 export function RecentPaymentDetails_abandoned(payment_hash: number): bigint {
26701 if(!isWasmInitialized) {
26702 throw new Error("initializeWasm() must be awaited first!");
26704 const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_hash);
26705 return nativeResponseValue;
26707 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
26709 export function PhantomRouteHints_free(this_obj: bigint): void {
26710 if(!isWasmInitialized) {
26711 throw new Error("initializeWasm() must be awaited first!");
26713 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
26714 // debug statements here
26716 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
26718 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
26719 if(!isWasmInitialized) {
26720 throw new Error("initializeWasm() must be awaited first!");
26722 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
26723 return nativeResponseValue;
26725 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
26727 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
26728 if(!isWasmInitialized) {
26729 throw new Error("initializeWasm() must be awaited first!");
26731 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
26732 // debug statements here
26734 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
26736 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
26737 if(!isWasmInitialized) {
26738 throw new Error("initializeWasm() must be awaited first!");
26740 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
26741 return nativeResponseValue;
26743 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
26745 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
26746 if(!isWasmInitialized) {
26747 throw new Error("initializeWasm() must be awaited first!");
26749 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
26750 // debug statements here
26752 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
26754 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
26755 if(!isWasmInitialized) {
26756 throw new Error("initializeWasm() must be awaited first!");
26758 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
26759 return nativeResponseValue;
26761 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26763 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
26764 if(!isWasmInitialized) {
26765 throw new Error("initializeWasm() must be awaited first!");
26767 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
26768 // debug statements here
26770 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
26772 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
26773 if(!isWasmInitialized) {
26774 throw new Error("initializeWasm() must be awaited first!");
26776 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
26777 return nativeResponseValue;
26779 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
26781 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
26782 if(!isWasmInitialized) {
26783 throw new Error("initializeWasm() must be awaited first!");
26785 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
26786 return nativeResponseValue;
26788 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
26790 export function PhantomRouteHints_clone(orig: bigint): bigint {
26791 if(!isWasmInitialized) {
26792 throw new Error("initializeWasm() must be awaited first!");
26794 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
26795 return nativeResponseValue;
26797 // 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, uint32_t current_timestamp);
26799 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, current_timestamp: number): bigint {
26800 if(!isWasmInitialized) {
26801 throw new Error("initializeWasm() must be awaited first!");
26803 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
26804 return nativeResponseValue;
26806 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
26808 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
26809 if(!isWasmInitialized) {
26810 throw new Error("initializeWasm() must be awaited first!");
26812 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
26813 return nativeResponseValue;
26815 // 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);
26817 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 {
26818 if(!isWasmInitialized) {
26819 throw new Error("initializeWasm() must be awaited first!");
26821 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
26822 return nativeResponseValue;
26824 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
26826 export function ChannelManager_list_channels(this_arg: bigint): number {
26827 if(!isWasmInitialized) {
26828 throw new Error("initializeWasm() must be awaited first!");
26830 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
26831 return nativeResponseValue;
26833 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
26835 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
26836 if(!isWasmInitialized) {
26837 throw new Error("initializeWasm() must be awaited first!");
26839 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
26840 return nativeResponseValue;
26842 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
26844 export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
26845 if(!isWasmInitialized) {
26846 throw new Error("initializeWasm() must be awaited first!");
26848 const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
26849 return nativeResponseValue;
26851 // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
26853 export function ChannelManager_list_recent_payments(this_arg: bigint): number {
26854 if(!isWasmInitialized) {
26855 throw new Error("initializeWasm() must be awaited first!");
26857 const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
26858 return nativeResponseValue;
26860 // 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);
26862 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
26863 if(!isWasmInitialized) {
26864 throw new Error("initializeWasm() must be awaited first!");
26866 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
26867 return nativeResponseValue;
26869 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_feerate_and_script(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKCOption_u32Z target_feerate_sats_per_1000_weight, struct LDKShutdownScript shutdown_script);
26871 export function ChannelManager_close_channel_with_feerate_and_script(this_arg: bigint, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: bigint, shutdown_script: bigint): bigint {
26872 if(!isWasmInitialized) {
26873 throw new Error("initializeWasm() must be awaited first!");
26875 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_feerate_and_script(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight, shutdown_script);
26876 return nativeResponseValue;
26878 // 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);
26880 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
26881 if(!isWasmInitialized) {
26882 throw new Error("initializeWasm() must be awaited first!");
26884 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
26885 return nativeResponseValue;
26887 // 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);
26889 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
26890 if(!isWasmInitialized) {
26891 throw new Error("initializeWasm() must be awaited first!");
26893 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
26894 return nativeResponseValue;
26896 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
26898 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
26899 if(!isWasmInitialized) {
26900 throw new Error("initializeWasm() must be awaited first!");
26902 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
26903 // debug statements here
26905 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
26907 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
26908 if(!isWasmInitialized) {
26909 throw new Error("initializeWasm() must be awaited first!");
26911 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
26912 // debug statements here
26914 // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment_with_route(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
26916 export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
26917 if(!isWasmInitialized) {
26918 throw new Error("initializeWasm() must be awaited first!");
26920 const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
26921 return nativeResponseValue;
26923 // MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
26925 export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
26926 if(!isWasmInitialized) {
26927 throw new Error("initializeWasm() must be awaited first!");
26929 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
26930 return nativeResponseValue;
26932 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
26934 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
26935 if(!isWasmInitialized) {
26936 throw new Error("initializeWasm() must be awaited first!");
26938 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
26939 // debug statements here
26941 // MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKCOption_PaymentPreimageZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
26943 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
26944 if(!isWasmInitialized) {
26945 throw new Error("initializeWasm() must be awaited first!");
26947 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
26948 return nativeResponseValue;
26950 // MUST_USE_RES struct LDKCResult_PaymentHashRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_PaymentPreimageZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
26952 export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
26953 if(!isWasmInitialized) {
26954 throw new Error("initializeWasm() must be awaited first!");
26956 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
26957 return nativeResponseValue;
26959 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
26961 export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
26962 if(!isWasmInitialized) {
26963 throw new Error("initializeWasm() must be awaited first!");
26965 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
26966 return nativeResponseValue;
26968 // 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);
26970 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
26971 if(!isWasmInitialized) {
26972 throw new Error("initializeWasm() must be awaited first!");
26974 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
26975 return nativeResponseValue;
26977 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_partial_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ThirtyTwoBytesZ channel_ids, const struct LDKChannelConfigUpdate *NONNULL_PTR config_update);
26979 export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
26980 if(!isWasmInitialized) {
26981 throw new Error("initializeWasm() must be awaited first!");
26983 const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
26984 return nativeResponseValue;
26986 // 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);
26988 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
26989 if(!isWasmInitialized) {
26990 throw new Error("initializeWasm() must be awaited first!");
26992 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
26993 return nativeResponseValue;
26995 // 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);
26997 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 {
26998 if(!isWasmInitialized) {
26999 throw new Error("initializeWasm() must be awaited first!");
27001 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
27002 return nativeResponseValue;
27004 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
27006 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
27007 if(!isWasmInitialized) {
27008 throw new Error("initializeWasm() must be awaited first!");
27010 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
27011 return nativeResponseValue;
27013 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
27015 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
27016 if(!isWasmInitialized) {
27017 throw new Error("initializeWasm() must be awaited first!");
27019 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
27020 // debug statements here
27022 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
27024 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
27025 if(!isWasmInitialized) {
27026 throw new Error("initializeWasm() must be awaited first!");
27028 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
27029 // debug statements here
27031 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
27033 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
27034 if(!isWasmInitialized) {
27035 throw new Error("initializeWasm() must be awaited first!");
27037 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
27038 // debug statements here
27040 // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], enum LDKFailureCode failure_code);
27042 export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: FailureCode): void {
27043 if(!isWasmInitialized) {
27044 throw new Error("initializeWasm() must be awaited first!");
27046 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
27047 // debug statements here
27049 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
27051 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
27052 if(!isWasmInitialized) {
27053 throw new Error("initializeWasm() must be awaited first!");
27055 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
27056 // debug statements here
27058 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
27060 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
27061 if(!isWasmInitialized) {
27062 throw new Error("initializeWasm() must be awaited first!");
27064 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
27065 return nativeResponseValue;
27067 // 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);
27069 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
27070 if(!isWasmInitialized) {
27071 throw new Error("initializeWasm() must be awaited first!");
27073 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
27074 return nativeResponseValue;
27076 // 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);
27078 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 {
27079 if(!isWasmInitialized) {
27080 throw new Error("initializeWasm() must be awaited first!");
27082 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
27083 return nativeResponseValue;
27085 // 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);
27087 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 {
27088 if(!isWasmInitialized) {
27089 throw new Error("initializeWasm() must be awaited first!");
27091 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
27092 return nativeResponseValue;
27094 // 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);
27096 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 {
27097 if(!isWasmInitialized) {
27098 throw new Error("initializeWasm() must be awaited first!");
27100 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);
27101 return nativeResponseValue;
27103 // 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);
27105 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
27106 if(!isWasmInitialized) {
27107 throw new Error("initializeWasm() must be awaited first!");
27109 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
27110 return nativeResponseValue;
27112 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
27114 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
27115 if(!isWasmInitialized) {
27116 throw new Error("initializeWasm() must be awaited first!");
27118 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
27119 return nativeResponseValue;
27121 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
27123 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
27124 if(!isWasmInitialized) {
27125 throw new Error("initializeWasm() must be awaited first!");
27127 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
27128 return nativeResponseValue;
27130 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
27132 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
27133 if(!isWasmInitialized) {
27134 throw new Error("initializeWasm() must be awaited first!");
27136 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
27137 return nativeResponseValue;
27139 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
27141 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
27142 if(!isWasmInitialized) {
27143 throw new Error("initializeWasm() must be awaited first!");
27145 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
27146 return nativeResponseValue;
27148 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
27150 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
27151 if(!isWasmInitialized) {
27152 throw new Error("initializeWasm() must be awaited first!");
27154 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
27155 return nativeResponseValue;
27157 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
27159 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
27160 if(!isWasmInitialized) {
27161 throw new Error("initializeWasm() must be awaited first!");
27163 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
27164 return nativeResponseValue;
27166 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
27168 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
27169 if(!isWasmInitialized) {
27170 throw new Error("initializeWasm() must be awaited first!");
27172 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
27173 return nativeResponseValue;
27175 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
27177 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
27178 if(!isWasmInitialized) {
27179 throw new Error("initializeWasm() must be awaited first!");
27181 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
27182 return nativeResponseValue;
27184 // MUST_USE_RES struct LDKFuture ChannelManager_get_persistable_update_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
27186 export function ChannelManager_get_persistable_update_future(this_arg: bigint): bigint {
27187 if(!isWasmInitialized) {
27188 throw new Error("initializeWasm() must be awaited first!");
27190 const nativeResponseValue = wasm.TS_ChannelManager_get_persistable_update_future(this_arg);
27191 return nativeResponseValue;
27193 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
27195 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
27196 if(!isWasmInitialized) {
27197 throw new Error("initializeWasm() must be awaited first!");
27199 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
27200 return nativeResponseValue;
27202 // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
27204 export function ChannelManager_node_features(this_arg: bigint): bigint {
27205 if(!isWasmInitialized) {
27206 throw new Error("initializeWasm() must be awaited first!");
27208 const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
27209 return nativeResponseValue;
27211 // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
27213 export function ChannelManager_channel_features(this_arg: bigint): bigint {
27214 if(!isWasmInitialized) {
27215 throw new Error("initializeWasm() must be awaited first!");
27217 const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
27218 return nativeResponseValue;
27220 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
27222 export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
27223 if(!isWasmInitialized) {
27224 throw new Error("initializeWasm() must be awaited first!");
27226 const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
27227 return nativeResponseValue;
27229 // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
27231 export function ChannelManager_init_features(this_arg: bigint): bigint {
27232 if(!isWasmInitialized) {
27233 throw new Error("initializeWasm() must be awaited first!");
27235 const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
27236 return nativeResponseValue;
27238 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
27240 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
27241 if(!isWasmInitialized) {
27242 throw new Error("initializeWasm() must be awaited first!");
27244 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
27245 return nativeResponseValue;
27247 // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
27249 export function provided_init_features(config: bigint): bigint {
27250 if(!isWasmInitialized) {
27251 throw new Error("initializeWasm() must be awaited first!");
27253 const nativeResponseValue = wasm.TS_provided_init_features(config);
27254 return nativeResponseValue;
27256 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
27258 export function CounterpartyForwardingInfo_write(obj: bigint): number {
27259 if(!isWasmInitialized) {
27260 throw new Error("initializeWasm() must be awaited first!");
27262 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
27263 return nativeResponseValue;
27265 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
27267 export function CounterpartyForwardingInfo_read(ser: number): bigint {
27268 if(!isWasmInitialized) {
27269 throw new Error("initializeWasm() must be awaited first!");
27271 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
27272 return nativeResponseValue;
27274 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
27276 export function ChannelCounterparty_write(obj: bigint): number {
27277 if(!isWasmInitialized) {
27278 throw new Error("initializeWasm() must be awaited first!");
27280 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
27281 return nativeResponseValue;
27283 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
27285 export function ChannelCounterparty_read(ser: number): bigint {
27286 if(!isWasmInitialized) {
27287 throw new Error("initializeWasm() must be awaited first!");
27289 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
27290 return nativeResponseValue;
27292 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
27294 export function ChannelDetails_write(obj: bigint): number {
27295 if(!isWasmInitialized) {
27296 throw new Error("initializeWasm() must be awaited first!");
27298 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
27299 return nativeResponseValue;
27301 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
27303 export function ChannelDetails_read(ser: number): bigint {
27304 if(!isWasmInitialized) {
27305 throw new Error("initializeWasm() must be awaited first!");
27307 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
27308 return nativeResponseValue;
27310 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
27312 export function PhantomRouteHints_write(obj: bigint): number {
27313 if(!isWasmInitialized) {
27314 throw new Error("initializeWasm() must be awaited first!");
27316 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
27317 return nativeResponseValue;
27319 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
27321 export function PhantomRouteHints_read(ser: number): bigint {
27322 if(!isWasmInitialized) {
27323 throw new Error("initializeWasm() must be awaited first!");
27325 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
27326 return nativeResponseValue;
27328 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
27330 export function ChannelManager_write(obj: bigint): number {
27331 if(!isWasmInitialized) {
27332 throw new Error("initializeWasm() must be awaited first!");
27334 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
27335 return nativeResponseValue;
27337 // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
27339 export function ChannelShutdownState_write(obj: bigint): number {
27340 if(!isWasmInitialized) {
27341 throw new Error("initializeWasm() must be awaited first!");
27343 const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
27344 return nativeResponseValue;
27346 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
27348 export function ChannelShutdownState_read(ser: number): bigint {
27349 if(!isWasmInitialized) {
27350 throw new Error("initializeWasm() must be awaited first!");
27352 const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
27353 return nativeResponseValue;
27355 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
27357 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
27358 if(!isWasmInitialized) {
27359 throw new Error("initializeWasm() must be awaited first!");
27361 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
27362 // debug statements here
27364 // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27366 export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
27367 if(!isWasmInitialized) {
27368 throw new Error("initializeWasm() must be awaited first!");
27370 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
27371 return nativeResponseValue;
27373 // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
27375 export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
27376 if(!isWasmInitialized) {
27377 throw new Error("initializeWasm() must be awaited first!");
27379 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
27380 // debug statements here
27382 // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27384 export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
27385 if(!isWasmInitialized) {
27386 throw new Error("initializeWasm() must be awaited first!");
27388 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
27389 return nativeResponseValue;
27391 // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
27393 export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
27394 if(!isWasmInitialized) {
27395 throw new Error("initializeWasm() must be awaited first!");
27397 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
27398 // debug statements here
27400 // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27402 export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
27403 if(!isWasmInitialized) {
27404 throw new Error("initializeWasm() must be awaited first!");
27406 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
27407 return nativeResponseValue;
27409 // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
27411 export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
27412 if(!isWasmInitialized) {
27413 throw new Error("initializeWasm() must be awaited first!");
27415 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
27416 // debug statements here
27418 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27420 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
27421 if(!isWasmInitialized) {
27422 throw new Error("initializeWasm() must be awaited first!");
27424 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
27425 return nativeResponseValue;
27427 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
27429 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
27430 if(!isWasmInitialized) {
27431 throw new Error("initializeWasm() must be awaited first!");
27433 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
27434 // debug statements here
27436 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27438 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
27439 if(!isWasmInitialized) {
27440 throw new Error("initializeWasm() must be awaited first!");
27442 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
27443 return nativeResponseValue;
27445 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
27447 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
27448 if(!isWasmInitialized) {
27449 throw new Error("initializeWasm() must be awaited first!");
27451 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
27452 // debug statements here
27454 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27456 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
27457 if(!isWasmInitialized) {
27458 throw new Error("initializeWasm() must be awaited first!");
27460 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
27461 return nativeResponseValue;
27463 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
27465 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
27466 if(!isWasmInitialized) {
27467 throw new Error("initializeWasm() must be awaited first!");
27469 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
27470 // debug statements here
27472 // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27474 export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
27475 if(!isWasmInitialized) {
27476 throw new Error("initializeWasm() must be awaited first!");
27478 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
27479 return nativeResponseValue;
27481 // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
27483 export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
27484 if(!isWasmInitialized) {
27485 throw new Error("initializeWasm() must be awaited first!");
27487 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
27488 // debug statements here
27490 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27492 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
27493 if(!isWasmInitialized) {
27494 throw new Error("initializeWasm() must be awaited first!");
27496 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
27497 return nativeResponseValue;
27499 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
27501 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
27502 if(!isWasmInitialized) {
27503 throw new Error("initializeWasm() must be awaited first!");
27505 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
27506 // debug statements here
27508 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
27510 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
27511 if(!isWasmInitialized) {
27512 throw new Error("initializeWasm() must be awaited first!");
27514 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
27515 return nativeResponseValue;
27517 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
27519 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
27520 if(!isWasmInitialized) {
27521 throw new Error("initializeWasm() must be awaited first!");
27523 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
27524 // debug statements here
27526 // 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);
27528 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 {
27529 if(!isWasmInitialized) {
27530 throw new Error("initializeWasm() must be awaited first!");
27532 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
27533 return nativeResponseValue;
27535 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
27537 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: bigint): bigint {
27538 if(!isWasmInitialized) {
27539 throw new Error("initializeWasm() must be awaited first!");
27541 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
27542 return nativeResponseValue;
27544 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
27546 export function ExpandedKey_free(this_obj: bigint): void {
27547 if(!isWasmInitialized) {
27548 throw new Error("initializeWasm() must be awaited first!");
27550 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
27551 // debug statements here
27553 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
27555 export function ExpandedKey_new(key_material: number): bigint {
27556 if(!isWasmInitialized) {
27557 throw new Error("initializeWasm() must be awaited first!");
27559 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
27560 return nativeResponseValue;
27562 // 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);
27564 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 {
27565 if(!isWasmInitialized) {
27566 throw new Error("initializeWasm() must be awaited first!");
27568 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, entropy_source, current_time, min_final_cltv_expiry_delta);
27569 return nativeResponseValue;
27571 // 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);
27573 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 {
27574 if(!isWasmInitialized) {
27575 throw new Error("initializeWasm() must be awaited first!");
27577 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta);
27578 return nativeResponseValue;
27580 // void DecodeError_free(struct LDKDecodeError this_ptr);
27582 export function DecodeError_free(this_ptr: bigint): void {
27583 if(!isWasmInitialized) {
27584 throw new Error("initializeWasm() must be awaited first!");
27586 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
27587 // debug statements here
27589 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
27591 export function DecodeError_clone_ptr(arg: bigint): bigint {
27592 if(!isWasmInitialized) {
27593 throw new Error("initializeWasm() must be awaited first!");
27595 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
27596 return nativeResponseValue;
27598 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
27600 export function DecodeError_clone(orig: bigint): bigint {
27601 if(!isWasmInitialized) {
27602 throw new Error("initializeWasm() must be awaited first!");
27604 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
27605 return nativeResponseValue;
27607 // struct LDKDecodeError DecodeError_unknown_version(void);
27609 export function DecodeError_unknown_version(): bigint {
27610 if(!isWasmInitialized) {
27611 throw new Error("initializeWasm() must be awaited first!");
27613 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
27614 return nativeResponseValue;
27616 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
27618 export function DecodeError_unknown_required_feature(): bigint {
27619 if(!isWasmInitialized) {
27620 throw new Error("initializeWasm() must be awaited first!");
27622 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
27623 return nativeResponseValue;
27625 // struct LDKDecodeError DecodeError_invalid_value(void);
27627 export function DecodeError_invalid_value(): bigint {
27628 if(!isWasmInitialized) {
27629 throw new Error("initializeWasm() must be awaited first!");
27631 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
27632 return nativeResponseValue;
27634 // struct LDKDecodeError DecodeError_short_read(void);
27636 export function DecodeError_short_read(): bigint {
27637 if(!isWasmInitialized) {
27638 throw new Error("initializeWasm() must be awaited first!");
27640 const nativeResponseValue = wasm.TS_DecodeError_short_read();
27641 return nativeResponseValue;
27643 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
27645 export function DecodeError_bad_length_descriptor(): bigint {
27646 if(!isWasmInitialized) {
27647 throw new Error("initializeWasm() must be awaited first!");
27649 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
27650 return nativeResponseValue;
27652 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
27654 export function DecodeError_io(a: IOError): bigint {
27655 if(!isWasmInitialized) {
27656 throw new Error("initializeWasm() must be awaited first!");
27658 const nativeResponseValue = wasm.TS_DecodeError_io(a);
27659 return nativeResponseValue;
27661 // struct LDKDecodeError DecodeError_unsupported_compression(void);
27663 export function DecodeError_unsupported_compression(): bigint {
27664 if(!isWasmInitialized) {
27665 throw new Error("initializeWasm() must be awaited first!");
27667 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
27668 return nativeResponseValue;
27670 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
27672 export function DecodeError_eq(a: bigint, b: bigint): boolean {
27673 if(!isWasmInitialized) {
27674 throw new Error("initializeWasm() must be awaited first!");
27676 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
27677 return nativeResponseValue;
27679 // void Init_free(struct LDKInit this_obj);
27681 export function Init_free(this_obj: bigint): void {
27682 if(!isWasmInitialized) {
27683 throw new Error("initializeWasm() must be awaited first!");
27685 const nativeResponseValue = wasm.TS_Init_free(this_obj);
27686 // debug statements here
27688 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
27690 export function Init_get_features(this_ptr: bigint): bigint {
27691 if(!isWasmInitialized) {
27692 throw new Error("initializeWasm() must be awaited first!");
27694 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
27695 return nativeResponseValue;
27697 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
27699 export function Init_set_features(this_ptr: bigint, val: bigint): void {
27700 if(!isWasmInitialized) {
27701 throw new Error("initializeWasm() must be awaited first!");
27703 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
27704 // debug statements here
27706 // struct LDKCOption_CVec_ChainHashZZ Init_get_networks(const struct LDKInit *NONNULL_PTR this_ptr);
27708 export function Init_get_networks(this_ptr: bigint): bigint {
27709 if(!isWasmInitialized) {
27710 throw new Error("initializeWasm() must be awaited first!");
27712 const nativeResponseValue = wasm.TS_Init_get_networks(this_ptr);
27713 return nativeResponseValue;
27715 // void Init_set_networks(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_CVec_ChainHashZZ val);
27717 export function Init_set_networks(this_ptr: bigint, val: bigint): void {
27718 if(!isWasmInitialized) {
27719 throw new Error("initializeWasm() must be awaited first!");
27721 const nativeResponseValue = wasm.TS_Init_set_networks(this_ptr, val);
27722 // debug statements here
27724 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
27726 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
27727 if(!isWasmInitialized) {
27728 throw new Error("initializeWasm() must be awaited first!");
27730 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
27731 return nativeResponseValue;
27733 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
27735 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
27736 if(!isWasmInitialized) {
27737 throw new Error("initializeWasm() must be awaited first!");
27739 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
27740 // debug statements here
27742 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_CVec_ChainHashZZ networks_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
27744 export function Init_new(features_arg: bigint, networks_arg: bigint, remote_network_address_arg: bigint): bigint {
27745 if(!isWasmInitialized) {
27746 throw new Error("initializeWasm() must be awaited first!");
27748 const nativeResponseValue = wasm.TS_Init_new(features_arg, networks_arg, remote_network_address_arg);
27749 return nativeResponseValue;
27751 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
27753 export function Init_clone_ptr(arg: bigint): bigint {
27754 if(!isWasmInitialized) {
27755 throw new Error("initializeWasm() must be awaited first!");
27757 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
27758 return nativeResponseValue;
27760 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
27762 export function Init_clone(orig: bigint): bigint {
27763 if(!isWasmInitialized) {
27764 throw new Error("initializeWasm() must be awaited first!");
27766 const nativeResponseValue = wasm.TS_Init_clone(orig);
27767 return nativeResponseValue;
27769 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
27771 export function Init_eq(a: bigint, b: bigint): boolean {
27772 if(!isWasmInitialized) {
27773 throw new Error("initializeWasm() must be awaited first!");
27775 const nativeResponseValue = wasm.TS_Init_eq(a, b);
27776 return nativeResponseValue;
27778 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
27780 export function ErrorMessage_free(this_obj: bigint): void {
27781 if(!isWasmInitialized) {
27782 throw new Error("initializeWasm() must be awaited first!");
27784 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
27785 // debug statements here
27787 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
27789 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
27790 if(!isWasmInitialized) {
27791 throw new Error("initializeWasm() must be awaited first!");
27793 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
27794 return nativeResponseValue;
27796 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27798 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
27799 if(!isWasmInitialized) {
27800 throw new Error("initializeWasm() must be awaited first!");
27802 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
27803 // debug statements here
27805 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
27807 export function ErrorMessage_get_data(this_ptr: bigint): number {
27808 if(!isWasmInitialized) {
27809 throw new Error("initializeWasm() must be awaited first!");
27811 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
27812 return nativeResponseValue;
27814 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
27816 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
27817 if(!isWasmInitialized) {
27818 throw new Error("initializeWasm() must be awaited first!");
27820 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
27821 // debug statements here
27823 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
27825 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
27826 if(!isWasmInitialized) {
27827 throw new Error("initializeWasm() must be awaited first!");
27829 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
27830 return nativeResponseValue;
27832 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
27834 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
27835 if(!isWasmInitialized) {
27836 throw new Error("initializeWasm() must be awaited first!");
27838 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
27839 return nativeResponseValue;
27841 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
27843 export function ErrorMessage_clone(orig: bigint): bigint {
27844 if(!isWasmInitialized) {
27845 throw new Error("initializeWasm() must be awaited first!");
27847 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
27848 return nativeResponseValue;
27850 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
27852 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
27853 if(!isWasmInitialized) {
27854 throw new Error("initializeWasm() must be awaited first!");
27856 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
27857 return nativeResponseValue;
27859 // void WarningMessage_free(struct LDKWarningMessage this_obj);
27861 export function WarningMessage_free(this_obj: bigint): void {
27862 if(!isWasmInitialized) {
27863 throw new Error("initializeWasm() must be awaited first!");
27865 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
27866 // debug statements here
27868 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
27870 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
27871 if(!isWasmInitialized) {
27872 throw new Error("initializeWasm() must be awaited first!");
27874 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
27875 return nativeResponseValue;
27877 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27879 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
27880 if(!isWasmInitialized) {
27881 throw new Error("initializeWasm() must be awaited first!");
27883 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
27884 // debug statements here
27886 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
27888 export function WarningMessage_get_data(this_ptr: bigint): number {
27889 if(!isWasmInitialized) {
27890 throw new Error("initializeWasm() must be awaited first!");
27892 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
27893 return nativeResponseValue;
27895 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
27897 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
27898 if(!isWasmInitialized) {
27899 throw new Error("initializeWasm() must be awaited first!");
27901 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
27902 // debug statements here
27904 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
27906 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
27907 if(!isWasmInitialized) {
27908 throw new Error("initializeWasm() must be awaited first!");
27910 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
27911 return nativeResponseValue;
27913 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
27915 export function WarningMessage_clone_ptr(arg: bigint): bigint {
27916 if(!isWasmInitialized) {
27917 throw new Error("initializeWasm() must be awaited first!");
27919 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
27920 return nativeResponseValue;
27922 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
27924 export function WarningMessage_clone(orig: bigint): bigint {
27925 if(!isWasmInitialized) {
27926 throw new Error("initializeWasm() must be awaited first!");
27928 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
27929 return nativeResponseValue;
27931 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
27933 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
27934 if(!isWasmInitialized) {
27935 throw new Error("initializeWasm() must be awaited first!");
27937 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
27938 return nativeResponseValue;
27940 // void Ping_free(struct LDKPing this_obj);
27942 export function Ping_free(this_obj: bigint): void {
27943 if(!isWasmInitialized) {
27944 throw new Error("initializeWasm() must be awaited first!");
27946 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
27947 // debug statements here
27949 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
27951 export function Ping_get_ponglen(this_ptr: bigint): number {
27952 if(!isWasmInitialized) {
27953 throw new Error("initializeWasm() must be awaited first!");
27955 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
27956 return nativeResponseValue;
27958 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
27960 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
27961 if(!isWasmInitialized) {
27962 throw new Error("initializeWasm() must be awaited first!");
27964 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
27965 // debug statements here
27967 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
27969 export function Ping_get_byteslen(this_ptr: bigint): number {
27970 if(!isWasmInitialized) {
27971 throw new Error("initializeWasm() must be awaited first!");
27973 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
27974 return nativeResponseValue;
27976 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
27978 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
27979 if(!isWasmInitialized) {
27980 throw new Error("initializeWasm() must be awaited first!");
27982 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
27983 // debug statements here
27985 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
27987 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
27988 if(!isWasmInitialized) {
27989 throw new Error("initializeWasm() must be awaited first!");
27991 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
27992 return nativeResponseValue;
27994 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
27996 export function Ping_clone_ptr(arg: bigint): bigint {
27997 if(!isWasmInitialized) {
27998 throw new Error("initializeWasm() must be awaited first!");
28000 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
28001 return nativeResponseValue;
28003 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
28005 export function Ping_clone(orig: bigint): bigint {
28006 if(!isWasmInitialized) {
28007 throw new Error("initializeWasm() must be awaited first!");
28009 const nativeResponseValue = wasm.TS_Ping_clone(orig);
28010 return nativeResponseValue;
28012 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
28014 export function Ping_eq(a: bigint, b: bigint): boolean {
28015 if(!isWasmInitialized) {
28016 throw new Error("initializeWasm() must be awaited first!");
28018 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
28019 return nativeResponseValue;
28021 // void Pong_free(struct LDKPong this_obj);
28023 export function Pong_free(this_obj: bigint): void {
28024 if(!isWasmInitialized) {
28025 throw new Error("initializeWasm() must be awaited first!");
28027 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
28028 // debug statements here
28030 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
28032 export function Pong_get_byteslen(this_ptr: bigint): number {
28033 if(!isWasmInitialized) {
28034 throw new Error("initializeWasm() must be awaited first!");
28036 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
28037 return nativeResponseValue;
28039 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
28041 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
28042 if(!isWasmInitialized) {
28043 throw new Error("initializeWasm() must be awaited first!");
28045 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
28046 // debug statements here
28048 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
28050 export function Pong_new(byteslen_arg: number): bigint {
28051 if(!isWasmInitialized) {
28052 throw new Error("initializeWasm() must be awaited first!");
28054 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
28055 return nativeResponseValue;
28057 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
28059 export function Pong_clone_ptr(arg: bigint): bigint {
28060 if(!isWasmInitialized) {
28061 throw new Error("initializeWasm() must be awaited first!");
28063 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
28064 return nativeResponseValue;
28066 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
28068 export function Pong_clone(orig: bigint): bigint {
28069 if(!isWasmInitialized) {
28070 throw new Error("initializeWasm() must be awaited first!");
28072 const nativeResponseValue = wasm.TS_Pong_clone(orig);
28073 return nativeResponseValue;
28075 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
28077 export function Pong_eq(a: bigint, b: bigint): boolean {
28078 if(!isWasmInitialized) {
28079 throw new Error("initializeWasm() must be awaited first!");
28081 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
28082 return nativeResponseValue;
28084 // void OpenChannel_free(struct LDKOpenChannel this_obj);
28086 export function OpenChannel_free(this_obj: bigint): void {
28087 if(!isWasmInitialized) {
28088 throw new Error("initializeWasm() must be awaited first!");
28090 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
28091 // debug statements here
28093 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
28095 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
28096 if(!isWasmInitialized) {
28097 throw new Error("initializeWasm() must be awaited first!");
28099 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
28100 return nativeResponseValue;
28102 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28104 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
28105 if(!isWasmInitialized) {
28106 throw new Error("initializeWasm() must be awaited first!");
28108 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
28109 // debug statements here
28111 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
28113 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
28114 if(!isWasmInitialized) {
28115 throw new Error("initializeWasm() must be awaited first!");
28117 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
28118 return nativeResponseValue;
28120 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28122 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
28123 if(!isWasmInitialized) {
28124 throw new Error("initializeWasm() must be awaited first!");
28126 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
28127 // debug statements here
28129 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28131 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
28132 if(!isWasmInitialized) {
28133 throw new Error("initializeWasm() must be awaited first!");
28135 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
28136 return nativeResponseValue;
28138 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
28140 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
28141 if(!isWasmInitialized) {
28142 throw new Error("initializeWasm() must be awaited first!");
28144 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
28145 // debug statements here
28147 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28149 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
28150 if(!isWasmInitialized) {
28151 throw new Error("initializeWasm() must be awaited first!");
28153 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
28154 return nativeResponseValue;
28156 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
28158 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
28159 if(!isWasmInitialized) {
28160 throw new Error("initializeWasm() must be awaited first!");
28162 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
28163 // debug statements here
28165 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28167 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
28168 if(!isWasmInitialized) {
28169 throw new Error("initializeWasm() must be awaited first!");
28171 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
28172 return nativeResponseValue;
28174 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
28176 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
28177 if(!isWasmInitialized) {
28178 throw new Error("initializeWasm() must be awaited first!");
28180 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
28181 // debug statements here
28183 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28185 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
28186 if(!isWasmInitialized) {
28187 throw new Error("initializeWasm() must be awaited first!");
28189 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
28190 return nativeResponseValue;
28192 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
28194 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
28195 if(!isWasmInitialized) {
28196 throw new Error("initializeWasm() must be awaited first!");
28198 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
28199 // debug statements here
28201 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28203 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
28204 if(!isWasmInitialized) {
28205 throw new Error("initializeWasm() must be awaited first!");
28207 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
28208 return nativeResponseValue;
28210 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
28212 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
28213 if(!isWasmInitialized) {
28214 throw new Error("initializeWasm() must be awaited first!");
28216 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
28217 // debug statements here
28219 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28221 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
28222 if(!isWasmInitialized) {
28223 throw new Error("initializeWasm() must be awaited first!");
28225 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
28226 return nativeResponseValue;
28228 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
28230 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
28231 if(!isWasmInitialized) {
28232 throw new Error("initializeWasm() must be awaited first!");
28234 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
28235 // debug statements here
28237 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28239 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
28240 if(!isWasmInitialized) {
28241 throw new Error("initializeWasm() must be awaited first!");
28243 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
28244 return nativeResponseValue;
28246 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
28248 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
28249 if(!isWasmInitialized) {
28250 throw new Error("initializeWasm() must be awaited first!");
28252 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
28253 // debug statements here
28255 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28257 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
28258 if(!isWasmInitialized) {
28259 throw new Error("initializeWasm() must be awaited first!");
28261 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
28262 return nativeResponseValue;
28264 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
28266 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
28267 if(!isWasmInitialized) {
28268 throw new Error("initializeWasm() must be awaited first!");
28270 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
28271 // debug statements here
28273 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28275 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
28276 if(!isWasmInitialized) {
28277 throw new Error("initializeWasm() must be awaited first!");
28279 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
28280 return nativeResponseValue;
28282 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
28284 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
28285 if(!isWasmInitialized) {
28286 throw new Error("initializeWasm() must be awaited first!");
28288 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
28289 // debug statements here
28291 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28293 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
28294 if(!isWasmInitialized) {
28295 throw new Error("initializeWasm() must be awaited first!");
28297 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
28298 return nativeResponseValue;
28300 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28302 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
28303 if(!isWasmInitialized) {
28304 throw new Error("initializeWasm() must be awaited first!");
28306 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
28307 // debug statements here
28309 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28311 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
28312 if(!isWasmInitialized) {
28313 throw new Error("initializeWasm() must be awaited first!");
28315 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
28316 return nativeResponseValue;
28318 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28320 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
28321 if(!isWasmInitialized) {
28322 throw new Error("initializeWasm() must be awaited first!");
28324 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
28325 // debug statements here
28327 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28329 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
28330 if(!isWasmInitialized) {
28331 throw new Error("initializeWasm() must be awaited first!");
28333 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
28334 return nativeResponseValue;
28336 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28338 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
28339 if(!isWasmInitialized) {
28340 throw new Error("initializeWasm() must be awaited first!");
28342 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
28343 // debug statements here
28345 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28347 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
28348 if(!isWasmInitialized) {
28349 throw new Error("initializeWasm() must be awaited first!");
28351 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
28352 return nativeResponseValue;
28354 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28356 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
28357 if(!isWasmInitialized) {
28358 throw new Error("initializeWasm() must be awaited first!");
28360 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
28361 // debug statements here
28363 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28365 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
28366 if(!isWasmInitialized) {
28367 throw new Error("initializeWasm() must be awaited first!");
28369 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
28370 return nativeResponseValue;
28372 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28374 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
28375 if(!isWasmInitialized) {
28376 throw new Error("initializeWasm() must be awaited first!");
28378 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
28379 // debug statements here
28381 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28383 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
28384 if(!isWasmInitialized) {
28385 throw new Error("initializeWasm() must be awaited first!");
28387 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
28388 return nativeResponseValue;
28390 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28392 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
28393 if(!isWasmInitialized) {
28394 throw new Error("initializeWasm() must be awaited first!");
28396 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
28397 // debug statements here
28399 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28401 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
28402 if(!isWasmInitialized) {
28403 throw new Error("initializeWasm() must be awaited first!");
28405 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
28406 return nativeResponseValue;
28408 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
28410 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
28411 if(!isWasmInitialized) {
28412 throw new Error("initializeWasm() must be awaited first!");
28414 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
28415 // debug statements here
28417 // struct LDKCOption_ScriptZ OpenChannel_get_shutdown_scriptpubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28419 export function OpenChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
28420 if(!isWasmInitialized) {
28421 throw new Error("initializeWasm() must be awaited first!");
28423 const nativeResponseValue = wasm.TS_OpenChannel_get_shutdown_scriptpubkey(this_ptr);
28424 return nativeResponseValue;
28426 // void OpenChannel_set_shutdown_scriptpubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKCOption_ScriptZ val);
28428 export function OpenChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
28429 if(!isWasmInitialized) {
28430 throw new Error("initializeWasm() must be awaited first!");
28432 const nativeResponseValue = wasm.TS_OpenChannel_set_shutdown_scriptpubkey(this_ptr, val);
28433 // debug statements here
28435 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
28437 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
28438 if(!isWasmInitialized) {
28439 throw new Error("initializeWasm() must be awaited first!");
28441 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
28442 return nativeResponseValue;
28444 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
28446 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
28447 if(!isWasmInitialized) {
28448 throw new Error("initializeWasm() must be awaited first!");
28450 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
28451 // debug statements here
28453 // MUST_USE_RES struct LDKOpenChannel OpenChannel_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKThirtyTwoBytes temporary_channel_id_arg, uint64_t funding_satoshis_arg, uint64_t push_msat_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t channel_reserve_satoshis_arg, uint64_t htlc_minimum_msat_arg, uint32_t feerate_per_kw_arg, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, 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, struct LDKPublicKey first_per_commitment_point_arg, uint8_t channel_flags_arg, struct LDKCOption_ScriptZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg);
28455 export function OpenChannel_new(chain_hash_arg: number, temporary_channel_id_arg: number, funding_satoshis_arg: bigint, push_msat_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, channel_reserve_satoshis_arg: bigint, htlc_minimum_msat_arg: bigint, feerate_per_kw_arg: number, to_self_delay_arg: number, max_accepted_htlcs_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_point_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number, first_per_commitment_point_arg: number, channel_flags_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint): bigint {
28456 if(!isWasmInitialized) {
28457 throw new Error("initializeWasm() must be awaited first!");
28459 const nativeResponseValue = wasm.TS_OpenChannel_new(chain_hash_arg, temporary_channel_id_arg, funding_satoshis_arg, push_msat_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, channel_reserve_satoshis_arg, htlc_minimum_msat_arg, feerate_per_kw_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, channel_flags_arg, shutdown_scriptpubkey_arg, channel_type_arg);
28460 return nativeResponseValue;
28462 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
28464 export function OpenChannel_clone_ptr(arg: bigint): bigint {
28465 if(!isWasmInitialized) {
28466 throw new Error("initializeWasm() must be awaited first!");
28468 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
28469 return nativeResponseValue;
28471 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
28473 export function OpenChannel_clone(orig: bigint): bigint {
28474 if(!isWasmInitialized) {
28475 throw new Error("initializeWasm() must be awaited first!");
28477 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
28478 return nativeResponseValue;
28480 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
28482 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
28483 if(!isWasmInitialized) {
28484 throw new Error("initializeWasm() must be awaited first!");
28486 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
28487 return nativeResponseValue;
28489 // void OpenChannelV2_free(struct LDKOpenChannelV2 this_obj);
28491 export function OpenChannelV2_free(this_obj: bigint): void {
28492 if(!isWasmInitialized) {
28493 throw new Error("initializeWasm() must be awaited first!");
28495 const nativeResponseValue = wasm.TS_OpenChannelV2_free(this_obj);
28496 // debug statements here
28498 // const uint8_t (*OpenChannelV2_get_chain_hash(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
28500 export function OpenChannelV2_get_chain_hash(this_ptr: bigint): number {
28501 if(!isWasmInitialized) {
28502 throw new Error("initializeWasm() must be awaited first!");
28504 const nativeResponseValue = wasm.TS_OpenChannelV2_get_chain_hash(this_ptr);
28505 return nativeResponseValue;
28507 // void OpenChannelV2_set_chain_hash(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28509 export function OpenChannelV2_set_chain_hash(this_ptr: bigint, val: number): void {
28510 if(!isWasmInitialized) {
28511 throw new Error("initializeWasm() must be awaited first!");
28513 const nativeResponseValue = wasm.TS_OpenChannelV2_set_chain_hash(this_ptr, val);
28514 // debug statements here
28516 // const uint8_t (*OpenChannelV2_get_temporary_channel_id(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
28518 export function OpenChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
28519 if(!isWasmInitialized) {
28520 throw new Error("initializeWasm() must be awaited first!");
28522 const nativeResponseValue = wasm.TS_OpenChannelV2_get_temporary_channel_id(this_ptr);
28523 return nativeResponseValue;
28525 // void OpenChannelV2_set_temporary_channel_id(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28527 export function OpenChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
28528 if(!isWasmInitialized) {
28529 throw new Error("initializeWasm() must be awaited first!");
28531 const nativeResponseValue = wasm.TS_OpenChannelV2_set_temporary_channel_id(this_ptr, val);
28532 // debug statements here
28534 // uint32_t OpenChannelV2_get_funding_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28536 export function OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr: bigint): number {
28537 if(!isWasmInitialized) {
28538 throw new Error("initializeWasm() must be awaited first!");
28540 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr);
28541 return nativeResponseValue;
28543 // void OpenChannelV2_set_funding_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
28545 export function OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
28546 if(!isWasmInitialized) {
28547 throw new Error("initializeWasm() must be awaited first!");
28549 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr, val);
28550 // debug statements here
28552 // uint32_t OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28554 export function OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr: bigint): number {
28555 if(!isWasmInitialized) {
28556 throw new Error("initializeWasm() must be awaited first!");
28558 const nativeResponseValue = wasm.TS_OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr);
28559 return nativeResponseValue;
28561 // void OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
28563 export function OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
28564 if(!isWasmInitialized) {
28565 throw new Error("initializeWasm() must be awaited first!");
28567 const nativeResponseValue = wasm.TS_OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr, val);
28568 // debug statements here
28570 // uint64_t OpenChannelV2_get_funding_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28572 export function OpenChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
28573 if(!isWasmInitialized) {
28574 throw new Error("initializeWasm() must be awaited first!");
28576 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_satoshis(this_ptr);
28577 return nativeResponseValue;
28579 // void OpenChannelV2_set_funding_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
28581 export function OpenChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
28582 if(!isWasmInitialized) {
28583 throw new Error("initializeWasm() must be awaited first!");
28585 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_satoshis(this_ptr, val);
28586 // debug statements here
28588 // uint64_t OpenChannelV2_get_dust_limit_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28590 export function OpenChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
28591 if(!isWasmInitialized) {
28592 throw new Error("initializeWasm() must be awaited first!");
28594 const nativeResponseValue = wasm.TS_OpenChannelV2_get_dust_limit_satoshis(this_ptr);
28595 return nativeResponseValue;
28597 // void OpenChannelV2_set_dust_limit_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
28599 export function OpenChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
28600 if(!isWasmInitialized) {
28601 throw new Error("initializeWasm() must be awaited first!");
28603 const nativeResponseValue = wasm.TS_OpenChannelV2_set_dust_limit_satoshis(this_ptr, val);
28604 // debug statements here
28606 // uint64_t OpenChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28608 export function OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
28609 if(!isWasmInitialized) {
28610 throw new Error("initializeWasm() must be awaited first!");
28612 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
28613 return nativeResponseValue;
28615 // void OpenChannelV2_set_max_htlc_value_in_flight_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
28617 export function OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
28618 if(!isWasmInitialized) {
28619 throw new Error("initializeWasm() must be awaited first!");
28621 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
28622 // debug statements here
28624 // uint64_t OpenChannelV2_get_htlc_minimum_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28626 export function OpenChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
28627 if(!isWasmInitialized) {
28628 throw new Error("initializeWasm() must be awaited first!");
28630 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_minimum_msat(this_ptr);
28631 return nativeResponseValue;
28633 // void OpenChannelV2_set_htlc_minimum_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
28635 export function OpenChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
28636 if(!isWasmInitialized) {
28637 throw new Error("initializeWasm() must be awaited first!");
28639 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_minimum_msat(this_ptr, val);
28640 // debug statements here
28642 // uint16_t OpenChannelV2_get_to_self_delay(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28644 export function OpenChannelV2_get_to_self_delay(this_ptr: bigint): number {
28645 if(!isWasmInitialized) {
28646 throw new Error("initializeWasm() must be awaited first!");
28648 const nativeResponseValue = wasm.TS_OpenChannelV2_get_to_self_delay(this_ptr);
28649 return nativeResponseValue;
28651 // void OpenChannelV2_set_to_self_delay(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
28653 export function OpenChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
28654 if(!isWasmInitialized) {
28655 throw new Error("initializeWasm() must be awaited first!");
28657 const nativeResponseValue = wasm.TS_OpenChannelV2_set_to_self_delay(this_ptr, val);
28658 // debug statements here
28660 // uint16_t OpenChannelV2_get_max_accepted_htlcs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28662 export function OpenChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
28663 if(!isWasmInitialized) {
28664 throw new Error("initializeWasm() must be awaited first!");
28666 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_accepted_htlcs(this_ptr);
28667 return nativeResponseValue;
28669 // void OpenChannelV2_set_max_accepted_htlcs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
28671 export function OpenChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
28672 if(!isWasmInitialized) {
28673 throw new Error("initializeWasm() must be awaited first!");
28675 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_accepted_htlcs(this_ptr, val);
28676 // debug statements here
28678 // uint32_t OpenChannelV2_get_locktime(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28680 export function OpenChannelV2_get_locktime(this_ptr: bigint): number {
28681 if(!isWasmInitialized) {
28682 throw new Error("initializeWasm() must be awaited first!");
28684 const nativeResponseValue = wasm.TS_OpenChannelV2_get_locktime(this_ptr);
28685 return nativeResponseValue;
28687 // void OpenChannelV2_set_locktime(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
28689 export function OpenChannelV2_set_locktime(this_ptr: bigint, val: number): void {
28690 if(!isWasmInitialized) {
28691 throw new Error("initializeWasm() must be awaited first!");
28693 const nativeResponseValue = wasm.TS_OpenChannelV2_set_locktime(this_ptr, val);
28694 // debug statements here
28696 // struct LDKPublicKey OpenChannelV2_get_funding_pubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28698 export function OpenChannelV2_get_funding_pubkey(this_ptr: bigint): number {
28699 if(!isWasmInitialized) {
28700 throw new Error("initializeWasm() must be awaited first!");
28702 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_pubkey(this_ptr);
28703 return nativeResponseValue;
28705 // void OpenChannelV2_set_funding_pubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28707 export function OpenChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
28708 if(!isWasmInitialized) {
28709 throw new Error("initializeWasm() must be awaited first!");
28711 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_pubkey(this_ptr, val);
28712 // debug statements here
28714 // struct LDKPublicKey OpenChannelV2_get_revocation_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28716 export function OpenChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
28717 if(!isWasmInitialized) {
28718 throw new Error("initializeWasm() must be awaited first!");
28720 const nativeResponseValue = wasm.TS_OpenChannelV2_get_revocation_basepoint(this_ptr);
28721 return nativeResponseValue;
28723 // void OpenChannelV2_set_revocation_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28725 export function OpenChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
28726 if(!isWasmInitialized) {
28727 throw new Error("initializeWasm() must be awaited first!");
28729 const nativeResponseValue = wasm.TS_OpenChannelV2_set_revocation_basepoint(this_ptr, val);
28730 // debug statements here
28732 // struct LDKPublicKey OpenChannelV2_get_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28734 export function OpenChannelV2_get_payment_basepoint(this_ptr: bigint): number {
28735 if(!isWasmInitialized) {
28736 throw new Error("initializeWasm() must be awaited first!");
28738 const nativeResponseValue = wasm.TS_OpenChannelV2_get_payment_basepoint(this_ptr);
28739 return nativeResponseValue;
28741 // void OpenChannelV2_set_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28743 export function OpenChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
28744 if(!isWasmInitialized) {
28745 throw new Error("initializeWasm() must be awaited first!");
28747 const nativeResponseValue = wasm.TS_OpenChannelV2_set_payment_basepoint(this_ptr, val);
28748 // debug statements here
28750 // struct LDKPublicKey OpenChannelV2_get_delayed_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28752 export function OpenChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
28753 if(!isWasmInitialized) {
28754 throw new Error("initializeWasm() must be awaited first!");
28756 const nativeResponseValue = wasm.TS_OpenChannelV2_get_delayed_payment_basepoint(this_ptr);
28757 return nativeResponseValue;
28759 // void OpenChannelV2_set_delayed_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28761 export function OpenChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
28762 if(!isWasmInitialized) {
28763 throw new Error("initializeWasm() must be awaited first!");
28765 const nativeResponseValue = wasm.TS_OpenChannelV2_set_delayed_payment_basepoint(this_ptr, val);
28766 // debug statements here
28768 // struct LDKPublicKey OpenChannelV2_get_htlc_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28770 export function OpenChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
28771 if(!isWasmInitialized) {
28772 throw new Error("initializeWasm() must be awaited first!");
28774 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_basepoint(this_ptr);
28775 return nativeResponseValue;
28777 // void OpenChannelV2_set_htlc_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28779 export function OpenChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
28780 if(!isWasmInitialized) {
28781 throw new Error("initializeWasm() must be awaited first!");
28783 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_basepoint(this_ptr, val);
28784 // debug statements here
28786 // struct LDKPublicKey OpenChannelV2_get_first_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28788 export function OpenChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
28789 if(!isWasmInitialized) {
28790 throw new Error("initializeWasm() must be awaited first!");
28792 const nativeResponseValue = wasm.TS_OpenChannelV2_get_first_per_commitment_point(this_ptr);
28793 return nativeResponseValue;
28795 // void OpenChannelV2_set_first_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28797 export function OpenChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
28798 if(!isWasmInitialized) {
28799 throw new Error("initializeWasm() must be awaited first!");
28801 const nativeResponseValue = wasm.TS_OpenChannelV2_set_first_per_commitment_point(this_ptr, val);
28802 // debug statements here
28804 // struct LDKPublicKey OpenChannelV2_get_second_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28806 export function OpenChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
28807 if(!isWasmInitialized) {
28808 throw new Error("initializeWasm() must be awaited first!");
28810 const nativeResponseValue = wasm.TS_OpenChannelV2_get_second_per_commitment_point(this_ptr);
28811 return nativeResponseValue;
28813 // void OpenChannelV2_set_second_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28815 export function OpenChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
28816 if(!isWasmInitialized) {
28817 throw new Error("initializeWasm() must be awaited first!");
28819 const nativeResponseValue = wasm.TS_OpenChannelV2_set_second_per_commitment_point(this_ptr, val);
28820 // debug statements here
28822 // uint8_t OpenChannelV2_get_channel_flags(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28824 export function OpenChannelV2_get_channel_flags(this_ptr: bigint): number {
28825 if(!isWasmInitialized) {
28826 throw new Error("initializeWasm() must be awaited first!");
28828 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_flags(this_ptr);
28829 return nativeResponseValue;
28831 // void OpenChannelV2_set_channel_flags(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint8_t val);
28833 export function OpenChannelV2_set_channel_flags(this_ptr: bigint, val: number): void {
28834 if(!isWasmInitialized) {
28835 throw new Error("initializeWasm() must be awaited first!");
28837 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_flags(this_ptr, val);
28838 // debug statements here
28840 // struct LDKCOption_ScriptZ OpenChannelV2_get_shutdown_scriptpubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28842 export function OpenChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
28843 if(!isWasmInitialized) {
28844 throw new Error("initializeWasm() must be awaited first!");
28846 const nativeResponseValue = wasm.TS_OpenChannelV2_get_shutdown_scriptpubkey(this_ptr);
28847 return nativeResponseValue;
28849 // void OpenChannelV2_set_shutdown_scriptpubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_ScriptZ val);
28851 export function OpenChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
28852 if(!isWasmInitialized) {
28853 throw new Error("initializeWasm() must be awaited first!");
28855 const nativeResponseValue = wasm.TS_OpenChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
28856 // debug statements here
28858 // struct LDKChannelTypeFeatures OpenChannelV2_get_channel_type(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28860 export function OpenChannelV2_get_channel_type(this_ptr: bigint): bigint {
28861 if(!isWasmInitialized) {
28862 throw new Error("initializeWasm() must be awaited first!");
28864 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_type(this_ptr);
28865 return nativeResponseValue;
28867 // void OpenChannelV2_set_channel_type(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
28869 export function OpenChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
28870 if(!isWasmInitialized) {
28871 throw new Error("initializeWasm() must be awaited first!");
28873 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_type(this_ptr, val);
28874 // debug statements here
28876 // enum LDKCOption_NoneZ OpenChannelV2_get_require_confirmed_inputs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
28878 export function OpenChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
28879 if(!isWasmInitialized) {
28880 throw new Error("initializeWasm() must be awaited first!");
28882 const nativeResponseValue = wasm.TS_OpenChannelV2_get_require_confirmed_inputs(this_ptr);
28883 return nativeResponseValue;
28885 // void OpenChannelV2_set_require_confirmed_inputs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
28887 export function OpenChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
28888 if(!isWasmInitialized) {
28889 throw new Error("initializeWasm() must be awaited first!");
28891 const nativeResponseValue = wasm.TS_OpenChannelV2_set_require_confirmed_inputs(this_ptr, val);
28892 // debug statements here
28894 // MUST_USE_RES struct LDKOpenChannelV2 OpenChannelV2_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKThirtyTwoBytes temporary_channel_id_arg, uint32_t funding_feerate_sat_per_1000_weight_arg, uint32_t commitment_feerate_sat_per_1000_weight_arg, uint64_t funding_satoshis_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t htlc_minimum_msat_arg, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, uint32_t locktime_arg, struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_basepoint_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg, struct LDKPublicKey first_per_commitment_point_arg, struct LDKPublicKey second_per_commitment_point_arg, uint8_t channel_flags_arg, struct LDKCOption_ScriptZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
28896 export function OpenChannelV2_new(chain_hash_arg: number, temporary_channel_id_arg: number, funding_feerate_sat_per_1000_weight_arg: number, commitment_feerate_sat_per_1000_weight_arg: number, funding_satoshis_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, htlc_minimum_msat_arg: bigint, to_self_delay_arg: number, max_accepted_htlcs_arg: number, locktime_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_basepoint_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number, first_per_commitment_point_arg: number, second_per_commitment_point_arg: number, channel_flags_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint, require_confirmed_inputs_arg: COption_NoneZ): bigint {
28897 if(!isWasmInitialized) {
28898 throw new Error("initializeWasm() must be awaited first!");
28900 const nativeResponseValue = wasm.TS_OpenChannelV2_new(chain_hash_arg, temporary_channel_id_arg, funding_feerate_sat_per_1000_weight_arg, commitment_feerate_sat_per_1000_weight_arg, funding_satoshis_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, to_self_delay_arg, max_accepted_htlcs_arg, locktime_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_basepoint_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, second_per_commitment_point_arg, channel_flags_arg, shutdown_scriptpubkey_arg, channel_type_arg, require_confirmed_inputs_arg);
28901 return nativeResponseValue;
28903 // uint64_t OpenChannelV2_clone_ptr(LDKOpenChannelV2 *NONNULL_PTR arg);
28905 export function OpenChannelV2_clone_ptr(arg: bigint): bigint {
28906 if(!isWasmInitialized) {
28907 throw new Error("initializeWasm() must be awaited first!");
28909 const nativeResponseValue = wasm.TS_OpenChannelV2_clone_ptr(arg);
28910 return nativeResponseValue;
28912 // struct LDKOpenChannelV2 OpenChannelV2_clone(const struct LDKOpenChannelV2 *NONNULL_PTR orig);
28914 export function OpenChannelV2_clone(orig: bigint): bigint {
28915 if(!isWasmInitialized) {
28916 throw new Error("initializeWasm() must be awaited first!");
28918 const nativeResponseValue = wasm.TS_OpenChannelV2_clone(orig);
28919 return nativeResponseValue;
28921 // bool OpenChannelV2_eq(const struct LDKOpenChannelV2 *NONNULL_PTR a, const struct LDKOpenChannelV2 *NONNULL_PTR b);
28923 export function OpenChannelV2_eq(a: bigint, b: bigint): boolean {
28924 if(!isWasmInitialized) {
28925 throw new Error("initializeWasm() must be awaited first!");
28927 const nativeResponseValue = wasm.TS_OpenChannelV2_eq(a, b);
28928 return nativeResponseValue;
28930 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
28932 export function AcceptChannel_free(this_obj: bigint): void {
28933 if(!isWasmInitialized) {
28934 throw new Error("initializeWasm() must be awaited first!");
28936 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
28937 // debug statements here
28939 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
28941 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
28942 if(!isWasmInitialized) {
28943 throw new Error("initializeWasm() must be awaited first!");
28945 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
28946 return nativeResponseValue;
28948 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
28950 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
28951 if(!isWasmInitialized) {
28952 throw new Error("initializeWasm() must be awaited first!");
28954 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
28955 // debug statements here
28957 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
28959 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
28960 if(!isWasmInitialized) {
28961 throw new Error("initializeWasm() must be awaited first!");
28963 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
28964 return nativeResponseValue;
28966 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
28968 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
28969 if(!isWasmInitialized) {
28970 throw new Error("initializeWasm() must be awaited first!");
28972 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
28973 // debug statements here
28975 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
28977 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
28978 if(!isWasmInitialized) {
28979 throw new Error("initializeWasm() must be awaited first!");
28981 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
28982 return nativeResponseValue;
28984 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
28986 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
28987 if(!isWasmInitialized) {
28988 throw new Error("initializeWasm() must be awaited first!");
28990 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
28991 // debug statements here
28993 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
28995 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
28996 if(!isWasmInitialized) {
28997 throw new Error("initializeWasm() must be awaited first!");
28999 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
29000 return nativeResponseValue;
29002 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
29004 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
29005 if(!isWasmInitialized) {
29006 throw new Error("initializeWasm() must be awaited first!");
29008 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
29009 // debug statements here
29011 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29013 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
29014 if(!isWasmInitialized) {
29015 throw new Error("initializeWasm() must be awaited first!");
29017 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
29018 return nativeResponseValue;
29020 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
29022 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
29023 if(!isWasmInitialized) {
29024 throw new Error("initializeWasm() must be awaited first!");
29026 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
29027 // debug statements here
29029 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29031 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
29032 if(!isWasmInitialized) {
29033 throw new Error("initializeWasm() must be awaited first!");
29035 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
29036 return nativeResponseValue;
29038 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
29040 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
29041 if(!isWasmInitialized) {
29042 throw new Error("initializeWasm() must be awaited first!");
29044 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
29045 // debug statements here
29047 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29049 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
29050 if(!isWasmInitialized) {
29051 throw new Error("initializeWasm() must be awaited first!");
29053 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
29054 return nativeResponseValue;
29056 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
29058 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
29059 if(!isWasmInitialized) {
29060 throw new Error("initializeWasm() must be awaited first!");
29062 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
29063 // debug statements here
29065 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29067 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
29068 if(!isWasmInitialized) {
29069 throw new Error("initializeWasm() must be awaited first!");
29071 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
29072 return nativeResponseValue;
29074 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
29076 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
29077 if(!isWasmInitialized) {
29078 throw new Error("initializeWasm() must be awaited first!");
29080 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
29081 // debug statements here
29083 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29085 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
29086 if(!isWasmInitialized) {
29087 throw new Error("initializeWasm() must be awaited first!");
29089 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
29090 return nativeResponseValue;
29092 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29094 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
29095 if(!isWasmInitialized) {
29096 throw new Error("initializeWasm() must be awaited first!");
29098 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
29099 // debug statements here
29101 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29103 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
29104 if(!isWasmInitialized) {
29105 throw new Error("initializeWasm() must be awaited first!");
29107 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
29108 return nativeResponseValue;
29110 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29112 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
29113 if(!isWasmInitialized) {
29114 throw new Error("initializeWasm() must be awaited first!");
29116 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
29117 // debug statements here
29119 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29121 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
29122 if(!isWasmInitialized) {
29123 throw new Error("initializeWasm() must be awaited first!");
29125 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
29126 return nativeResponseValue;
29128 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29130 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
29131 if(!isWasmInitialized) {
29132 throw new Error("initializeWasm() must be awaited first!");
29134 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
29135 // debug statements here
29137 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29139 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
29140 if(!isWasmInitialized) {
29141 throw new Error("initializeWasm() must be awaited first!");
29143 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
29144 return nativeResponseValue;
29146 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29148 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
29149 if(!isWasmInitialized) {
29150 throw new Error("initializeWasm() must be awaited first!");
29152 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
29153 // debug statements here
29155 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29157 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
29158 if(!isWasmInitialized) {
29159 throw new Error("initializeWasm() must be awaited first!");
29161 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
29162 return nativeResponseValue;
29164 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29166 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
29167 if(!isWasmInitialized) {
29168 throw new Error("initializeWasm() must be awaited first!");
29170 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
29171 // debug statements here
29173 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29175 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
29176 if(!isWasmInitialized) {
29177 throw new Error("initializeWasm() must be awaited first!");
29179 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
29180 return nativeResponseValue;
29182 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29184 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
29185 if(!isWasmInitialized) {
29186 throw new Error("initializeWasm() must be awaited first!");
29188 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
29189 // debug statements here
29191 // struct LDKCOption_ScriptZ AcceptChannel_get_shutdown_scriptpubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29193 export function AcceptChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
29194 if(!isWasmInitialized) {
29195 throw new Error("initializeWasm() must be awaited first!");
29197 const nativeResponseValue = wasm.TS_AcceptChannel_get_shutdown_scriptpubkey(this_ptr);
29198 return nativeResponseValue;
29200 // void AcceptChannel_set_shutdown_scriptpubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKCOption_ScriptZ val);
29202 export function AcceptChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
29203 if(!isWasmInitialized) {
29204 throw new Error("initializeWasm() must be awaited first!");
29206 const nativeResponseValue = wasm.TS_AcceptChannel_set_shutdown_scriptpubkey(this_ptr, val);
29207 // debug statements here
29209 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
29211 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
29212 if(!isWasmInitialized) {
29213 throw new Error("initializeWasm() must be awaited first!");
29215 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
29216 return nativeResponseValue;
29218 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
29220 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
29221 if(!isWasmInitialized) {
29222 throw new Error("initializeWasm() must be awaited first!");
29224 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
29225 // debug statements here
29227 // MUST_USE_RES struct LDKAcceptChannel AcceptChannel_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t channel_reserve_satoshis_arg, uint64_t htlc_minimum_msat_arg, uint32_t minimum_depth_arg, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, 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, struct LDKPublicKey first_per_commitment_point_arg, struct LDKCOption_ScriptZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg);
29229 export function AcceptChannel_new(temporary_channel_id_arg: number, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, channel_reserve_satoshis_arg: bigint, htlc_minimum_msat_arg: bigint, minimum_depth_arg: number, to_self_delay_arg: number, max_accepted_htlcs_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_point_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number, first_per_commitment_point_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint): bigint {
29230 if(!isWasmInitialized) {
29231 throw new Error("initializeWasm() must be awaited first!");
29233 const nativeResponseValue = wasm.TS_AcceptChannel_new(temporary_channel_id_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, channel_reserve_satoshis_arg, htlc_minimum_msat_arg, minimum_depth_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, shutdown_scriptpubkey_arg, channel_type_arg);
29234 return nativeResponseValue;
29236 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
29238 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
29239 if(!isWasmInitialized) {
29240 throw new Error("initializeWasm() must be awaited first!");
29242 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
29243 return nativeResponseValue;
29245 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
29247 export function AcceptChannel_clone(orig: bigint): bigint {
29248 if(!isWasmInitialized) {
29249 throw new Error("initializeWasm() must be awaited first!");
29251 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
29252 return nativeResponseValue;
29254 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
29256 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
29257 if(!isWasmInitialized) {
29258 throw new Error("initializeWasm() must be awaited first!");
29260 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
29261 return nativeResponseValue;
29263 // void AcceptChannelV2_free(struct LDKAcceptChannelV2 this_obj);
29265 export function AcceptChannelV2_free(this_obj: bigint): void {
29266 if(!isWasmInitialized) {
29267 throw new Error("initializeWasm() must be awaited first!");
29269 const nativeResponseValue = wasm.TS_AcceptChannelV2_free(this_obj);
29270 // debug statements here
29272 // const uint8_t (*AcceptChannelV2_get_temporary_channel_id(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr))[32];
29274 export function AcceptChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
29275 if(!isWasmInitialized) {
29276 throw new Error("initializeWasm() must be awaited first!");
29278 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_temporary_channel_id(this_ptr);
29279 return nativeResponseValue;
29281 // void AcceptChannelV2_set_temporary_channel_id(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29283 export function AcceptChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
29284 if(!isWasmInitialized) {
29285 throw new Error("initializeWasm() must be awaited first!");
29287 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_temporary_channel_id(this_ptr, val);
29288 // debug statements here
29290 // uint64_t AcceptChannelV2_get_funding_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29292 export function AcceptChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
29293 if(!isWasmInitialized) {
29294 throw new Error("initializeWasm() must be awaited first!");
29296 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_satoshis(this_ptr);
29297 return nativeResponseValue;
29299 // void AcceptChannelV2_set_funding_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
29301 export function AcceptChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
29302 if(!isWasmInitialized) {
29303 throw new Error("initializeWasm() must be awaited first!");
29305 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_satoshis(this_ptr, val);
29306 // debug statements here
29308 // uint64_t AcceptChannelV2_get_dust_limit_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29310 export function AcceptChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
29311 if(!isWasmInitialized) {
29312 throw new Error("initializeWasm() must be awaited first!");
29314 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_dust_limit_satoshis(this_ptr);
29315 return nativeResponseValue;
29317 // void AcceptChannelV2_set_dust_limit_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
29319 export function AcceptChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
29320 if(!isWasmInitialized) {
29321 throw new Error("initializeWasm() must be awaited first!");
29323 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_dust_limit_satoshis(this_ptr, val);
29324 // debug statements here
29326 // uint64_t AcceptChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29328 export function AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
29329 if(!isWasmInitialized) {
29330 throw new Error("initializeWasm() must be awaited first!");
29332 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
29333 return nativeResponseValue;
29335 // void AcceptChannelV2_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
29337 export function AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
29338 if(!isWasmInitialized) {
29339 throw new Error("initializeWasm() must be awaited first!");
29341 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
29342 // debug statements here
29344 // uint64_t AcceptChannelV2_get_htlc_minimum_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29346 export function AcceptChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
29347 if(!isWasmInitialized) {
29348 throw new Error("initializeWasm() must be awaited first!");
29350 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_minimum_msat(this_ptr);
29351 return nativeResponseValue;
29353 // void AcceptChannelV2_set_htlc_minimum_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
29355 export function AcceptChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
29356 if(!isWasmInitialized) {
29357 throw new Error("initializeWasm() must be awaited first!");
29359 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_minimum_msat(this_ptr, val);
29360 // debug statements here
29362 // uint32_t AcceptChannelV2_get_minimum_depth(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29364 export function AcceptChannelV2_get_minimum_depth(this_ptr: bigint): number {
29365 if(!isWasmInitialized) {
29366 throw new Error("initializeWasm() must be awaited first!");
29368 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_minimum_depth(this_ptr);
29369 return nativeResponseValue;
29371 // void AcceptChannelV2_set_minimum_depth(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
29373 export function AcceptChannelV2_set_minimum_depth(this_ptr: bigint, val: number): void {
29374 if(!isWasmInitialized) {
29375 throw new Error("initializeWasm() must be awaited first!");
29377 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_minimum_depth(this_ptr, val);
29378 // debug statements here
29380 // uint16_t AcceptChannelV2_get_to_self_delay(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29382 export function AcceptChannelV2_get_to_self_delay(this_ptr: bigint): number {
29383 if(!isWasmInitialized) {
29384 throw new Error("initializeWasm() must be awaited first!");
29386 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_to_self_delay(this_ptr);
29387 return nativeResponseValue;
29389 // void AcceptChannelV2_set_to_self_delay(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
29391 export function AcceptChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
29392 if(!isWasmInitialized) {
29393 throw new Error("initializeWasm() must be awaited first!");
29395 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_to_self_delay(this_ptr, val);
29396 // debug statements here
29398 // uint16_t AcceptChannelV2_get_max_accepted_htlcs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29400 export function AcceptChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
29401 if(!isWasmInitialized) {
29402 throw new Error("initializeWasm() must be awaited first!");
29404 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_accepted_htlcs(this_ptr);
29405 return nativeResponseValue;
29407 // void AcceptChannelV2_set_max_accepted_htlcs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
29409 export function AcceptChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
29410 if(!isWasmInitialized) {
29411 throw new Error("initializeWasm() must be awaited first!");
29413 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_accepted_htlcs(this_ptr, val);
29414 // debug statements here
29416 // struct LDKPublicKey AcceptChannelV2_get_funding_pubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29418 export function AcceptChannelV2_get_funding_pubkey(this_ptr: bigint): number {
29419 if(!isWasmInitialized) {
29420 throw new Error("initializeWasm() must be awaited first!");
29422 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_pubkey(this_ptr);
29423 return nativeResponseValue;
29425 // void AcceptChannelV2_set_funding_pubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29427 export function AcceptChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
29428 if(!isWasmInitialized) {
29429 throw new Error("initializeWasm() must be awaited first!");
29431 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_pubkey(this_ptr, val);
29432 // debug statements here
29434 // struct LDKPublicKey AcceptChannelV2_get_revocation_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29436 export function AcceptChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
29437 if(!isWasmInitialized) {
29438 throw new Error("initializeWasm() must be awaited first!");
29440 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_revocation_basepoint(this_ptr);
29441 return nativeResponseValue;
29443 // void AcceptChannelV2_set_revocation_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29445 export function AcceptChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
29446 if(!isWasmInitialized) {
29447 throw new Error("initializeWasm() must be awaited first!");
29449 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_revocation_basepoint(this_ptr, val);
29450 // debug statements here
29452 // struct LDKPublicKey AcceptChannelV2_get_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29454 export function AcceptChannelV2_get_payment_basepoint(this_ptr: bigint): number {
29455 if(!isWasmInitialized) {
29456 throw new Error("initializeWasm() must be awaited first!");
29458 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_payment_basepoint(this_ptr);
29459 return nativeResponseValue;
29461 // void AcceptChannelV2_set_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29463 export function AcceptChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
29464 if(!isWasmInitialized) {
29465 throw new Error("initializeWasm() must be awaited first!");
29467 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_payment_basepoint(this_ptr, val);
29468 // debug statements here
29470 // struct LDKPublicKey AcceptChannelV2_get_delayed_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29472 export function AcceptChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
29473 if(!isWasmInitialized) {
29474 throw new Error("initializeWasm() must be awaited first!");
29476 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_delayed_payment_basepoint(this_ptr);
29477 return nativeResponseValue;
29479 // void AcceptChannelV2_set_delayed_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29481 export function AcceptChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
29482 if(!isWasmInitialized) {
29483 throw new Error("initializeWasm() must be awaited first!");
29485 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_delayed_payment_basepoint(this_ptr, val);
29486 // debug statements here
29488 // struct LDKPublicKey AcceptChannelV2_get_htlc_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29490 export function AcceptChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
29491 if(!isWasmInitialized) {
29492 throw new Error("initializeWasm() must be awaited first!");
29494 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_basepoint(this_ptr);
29495 return nativeResponseValue;
29497 // void AcceptChannelV2_set_htlc_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29499 export function AcceptChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
29500 if(!isWasmInitialized) {
29501 throw new Error("initializeWasm() must be awaited first!");
29503 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_basepoint(this_ptr, val);
29504 // debug statements here
29506 // struct LDKPublicKey AcceptChannelV2_get_first_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29508 export function AcceptChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
29509 if(!isWasmInitialized) {
29510 throw new Error("initializeWasm() must be awaited first!");
29512 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_first_per_commitment_point(this_ptr);
29513 return nativeResponseValue;
29515 // void AcceptChannelV2_set_first_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29517 export function AcceptChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
29518 if(!isWasmInitialized) {
29519 throw new Error("initializeWasm() must be awaited first!");
29521 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_first_per_commitment_point(this_ptr, val);
29522 // debug statements here
29524 // struct LDKPublicKey AcceptChannelV2_get_second_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29526 export function AcceptChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
29527 if(!isWasmInitialized) {
29528 throw new Error("initializeWasm() must be awaited first!");
29530 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_second_per_commitment_point(this_ptr);
29531 return nativeResponseValue;
29533 // void AcceptChannelV2_set_second_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29535 export function AcceptChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
29536 if(!isWasmInitialized) {
29537 throw new Error("initializeWasm() must be awaited first!");
29539 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_second_per_commitment_point(this_ptr, val);
29540 // debug statements here
29542 // struct LDKCOption_ScriptZ AcceptChannelV2_get_shutdown_scriptpubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29544 export function AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
29545 if(!isWasmInitialized) {
29546 throw new Error("initializeWasm() must be awaited first!");
29548 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr);
29549 return nativeResponseValue;
29551 // void AcceptChannelV2_set_shutdown_scriptpubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_ScriptZ val);
29553 export function AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
29554 if(!isWasmInitialized) {
29555 throw new Error("initializeWasm() must be awaited first!");
29557 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
29558 // debug statements here
29560 // struct LDKChannelTypeFeatures AcceptChannelV2_get_channel_type(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29562 export function AcceptChannelV2_get_channel_type(this_ptr: bigint): bigint {
29563 if(!isWasmInitialized) {
29564 throw new Error("initializeWasm() must be awaited first!");
29566 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_channel_type(this_ptr);
29567 return nativeResponseValue;
29569 // void AcceptChannelV2_set_channel_type(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
29571 export function AcceptChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
29572 if(!isWasmInitialized) {
29573 throw new Error("initializeWasm() must be awaited first!");
29575 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_channel_type(this_ptr, val);
29576 // debug statements here
29578 // enum LDKCOption_NoneZ AcceptChannelV2_get_require_confirmed_inputs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
29580 export function AcceptChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
29581 if(!isWasmInitialized) {
29582 throw new Error("initializeWasm() must be awaited first!");
29584 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_require_confirmed_inputs(this_ptr);
29585 return nativeResponseValue;
29587 // void AcceptChannelV2_set_require_confirmed_inputs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
29589 export function AcceptChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
29590 if(!isWasmInitialized) {
29591 throw new Error("initializeWasm() must be awaited first!");
29593 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_require_confirmed_inputs(this_ptr, val);
29594 // debug statements here
29596 // MUST_USE_RES struct LDKAcceptChannelV2 AcceptChannelV2_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, uint64_t funding_satoshis_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t htlc_minimum_msat_arg, uint32_t minimum_depth_arg, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_basepoint_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg, struct LDKPublicKey first_per_commitment_point_arg, struct LDKPublicKey second_per_commitment_point_arg, struct LDKCOption_ScriptZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
29598 export function AcceptChannelV2_new(temporary_channel_id_arg: number, funding_satoshis_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, htlc_minimum_msat_arg: bigint, minimum_depth_arg: number, to_self_delay_arg: number, max_accepted_htlcs_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_basepoint_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number, first_per_commitment_point_arg: number, second_per_commitment_point_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint, require_confirmed_inputs_arg: COption_NoneZ): bigint {
29599 if(!isWasmInitialized) {
29600 throw new Error("initializeWasm() must be awaited first!");
29602 const nativeResponseValue = wasm.TS_AcceptChannelV2_new(temporary_channel_id_arg, funding_satoshis_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, minimum_depth_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_basepoint_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, second_per_commitment_point_arg, shutdown_scriptpubkey_arg, channel_type_arg, require_confirmed_inputs_arg);
29603 return nativeResponseValue;
29605 // uint64_t AcceptChannelV2_clone_ptr(LDKAcceptChannelV2 *NONNULL_PTR arg);
29607 export function AcceptChannelV2_clone_ptr(arg: bigint): bigint {
29608 if(!isWasmInitialized) {
29609 throw new Error("initializeWasm() must be awaited first!");
29611 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone_ptr(arg);
29612 return nativeResponseValue;
29614 // struct LDKAcceptChannelV2 AcceptChannelV2_clone(const struct LDKAcceptChannelV2 *NONNULL_PTR orig);
29616 export function AcceptChannelV2_clone(orig: bigint): bigint {
29617 if(!isWasmInitialized) {
29618 throw new Error("initializeWasm() must be awaited first!");
29620 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone(orig);
29621 return nativeResponseValue;
29623 // bool AcceptChannelV2_eq(const struct LDKAcceptChannelV2 *NONNULL_PTR a, const struct LDKAcceptChannelV2 *NONNULL_PTR b);
29625 export function AcceptChannelV2_eq(a: bigint, b: bigint): boolean {
29626 if(!isWasmInitialized) {
29627 throw new Error("initializeWasm() must be awaited first!");
29629 const nativeResponseValue = wasm.TS_AcceptChannelV2_eq(a, b);
29630 return nativeResponseValue;
29632 // void FundingCreated_free(struct LDKFundingCreated this_obj);
29634 export function FundingCreated_free(this_obj: bigint): void {
29635 if(!isWasmInitialized) {
29636 throw new Error("initializeWasm() must be awaited first!");
29638 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
29639 // debug statements here
29641 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
29643 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
29644 if(!isWasmInitialized) {
29645 throw new Error("initializeWasm() must be awaited first!");
29647 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
29648 return nativeResponseValue;
29650 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29652 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
29653 if(!isWasmInitialized) {
29654 throw new Error("initializeWasm() must be awaited first!");
29656 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
29657 // debug statements here
29659 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
29661 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
29662 if(!isWasmInitialized) {
29663 throw new Error("initializeWasm() must be awaited first!");
29665 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
29666 return nativeResponseValue;
29668 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29670 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
29671 if(!isWasmInitialized) {
29672 throw new Error("initializeWasm() must be awaited first!");
29674 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
29675 // debug statements here
29677 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
29679 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
29680 if(!isWasmInitialized) {
29681 throw new Error("initializeWasm() must be awaited first!");
29683 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
29684 return nativeResponseValue;
29686 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
29688 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
29689 if(!isWasmInitialized) {
29690 throw new Error("initializeWasm() must be awaited first!");
29692 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
29693 // debug statements here
29695 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
29697 export function FundingCreated_get_signature(this_ptr: bigint): number {
29698 if(!isWasmInitialized) {
29699 throw new Error("initializeWasm() must be awaited first!");
29701 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
29702 return nativeResponseValue;
29704 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
29706 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
29707 if(!isWasmInitialized) {
29708 throw new Error("initializeWasm() must be awaited first!");
29710 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
29711 // debug statements here
29713 // 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);
29715 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
29716 if(!isWasmInitialized) {
29717 throw new Error("initializeWasm() must be awaited first!");
29719 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
29720 return nativeResponseValue;
29722 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
29724 export function FundingCreated_clone_ptr(arg: bigint): bigint {
29725 if(!isWasmInitialized) {
29726 throw new Error("initializeWasm() must be awaited first!");
29728 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
29729 return nativeResponseValue;
29731 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
29733 export function FundingCreated_clone(orig: bigint): bigint {
29734 if(!isWasmInitialized) {
29735 throw new Error("initializeWasm() must be awaited first!");
29737 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
29738 return nativeResponseValue;
29740 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
29742 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
29743 if(!isWasmInitialized) {
29744 throw new Error("initializeWasm() must be awaited first!");
29746 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
29747 return nativeResponseValue;
29749 // void FundingSigned_free(struct LDKFundingSigned this_obj);
29751 export function FundingSigned_free(this_obj: bigint): void {
29752 if(!isWasmInitialized) {
29753 throw new Error("initializeWasm() must be awaited first!");
29755 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
29756 // debug statements here
29758 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
29760 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
29761 if(!isWasmInitialized) {
29762 throw new Error("initializeWasm() must be awaited first!");
29764 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
29765 return nativeResponseValue;
29767 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29769 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
29770 if(!isWasmInitialized) {
29771 throw new Error("initializeWasm() must be awaited first!");
29773 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
29774 // debug statements here
29776 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
29778 export function FundingSigned_get_signature(this_ptr: bigint): number {
29779 if(!isWasmInitialized) {
29780 throw new Error("initializeWasm() must be awaited first!");
29782 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
29783 return nativeResponseValue;
29785 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
29787 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
29788 if(!isWasmInitialized) {
29789 throw new Error("initializeWasm() must be awaited first!");
29791 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
29792 // debug statements here
29794 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
29796 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
29797 if(!isWasmInitialized) {
29798 throw new Error("initializeWasm() must be awaited first!");
29800 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
29801 return nativeResponseValue;
29803 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
29805 export function FundingSigned_clone_ptr(arg: bigint): bigint {
29806 if(!isWasmInitialized) {
29807 throw new Error("initializeWasm() must be awaited first!");
29809 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
29810 return nativeResponseValue;
29812 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
29814 export function FundingSigned_clone(orig: bigint): bigint {
29815 if(!isWasmInitialized) {
29816 throw new Error("initializeWasm() must be awaited first!");
29818 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
29819 return nativeResponseValue;
29821 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
29823 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
29824 if(!isWasmInitialized) {
29825 throw new Error("initializeWasm() must be awaited first!");
29827 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
29828 return nativeResponseValue;
29830 // void ChannelReady_free(struct LDKChannelReady this_obj);
29832 export function ChannelReady_free(this_obj: bigint): void {
29833 if(!isWasmInitialized) {
29834 throw new Error("initializeWasm() must be awaited first!");
29836 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
29837 // debug statements here
29839 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
29841 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
29842 if(!isWasmInitialized) {
29843 throw new Error("initializeWasm() must be awaited first!");
29845 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
29846 return nativeResponseValue;
29848 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29850 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
29851 if(!isWasmInitialized) {
29852 throw new Error("initializeWasm() must be awaited first!");
29854 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
29855 // debug statements here
29857 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
29859 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
29860 if(!isWasmInitialized) {
29861 throw new Error("initializeWasm() must be awaited first!");
29863 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
29864 return nativeResponseValue;
29866 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29868 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
29869 if(!isWasmInitialized) {
29870 throw new Error("initializeWasm() must be awaited first!");
29872 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
29873 // debug statements here
29875 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
29877 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
29878 if(!isWasmInitialized) {
29879 throw new Error("initializeWasm() must be awaited first!");
29881 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
29882 return nativeResponseValue;
29884 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29886 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
29887 if(!isWasmInitialized) {
29888 throw new Error("initializeWasm() must be awaited first!");
29890 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
29891 // debug statements here
29893 // 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);
29895 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
29896 if(!isWasmInitialized) {
29897 throw new Error("initializeWasm() must be awaited first!");
29899 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
29900 return nativeResponseValue;
29902 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
29904 export function ChannelReady_clone_ptr(arg: bigint): bigint {
29905 if(!isWasmInitialized) {
29906 throw new Error("initializeWasm() must be awaited first!");
29908 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
29909 return nativeResponseValue;
29911 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
29913 export function ChannelReady_clone(orig: bigint): bigint {
29914 if(!isWasmInitialized) {
29915 throw new Error("initializeWasm() must be awaited first!");
29917 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
29918 return nativeResponseValue;
29920 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
29922 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
29923 if(!isWasmInitialized) {
29924 throw new Error("initializeWasm() must be awaited first!");
29926 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
29927 return nativeResponseValue;
29929 // void TxAddInput_free(struct LDKTxAddInput this_obj);
29931 export function TxAddInput_free(this_obj: bigint): void {
29932 if(!isWasmInitialized) {
29933 throw new Error("initializeWasm() must be awaited first!");
29935 const nativeResponseValue = wasm.TS_TxAddInput_free(this_obj);
29936 // debug statements here
29938 // const uint8_t (*TxAddInput_get_channel_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr))[32];
29940 export function TxAddInput_get_channel_id(this_ptr: bigint): number {
29941 if(!isWasmInitialized) {
29942 throw new Error("initializeWasm() must be awaited first!");
29944 const nativeResponseValue = wasm.TS_TxAddInput_get_channel_id(this_ptr);
29945 return nativeResponseValue;
29947 // void TxAddInput_set_channel_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29949 export function TxAddInput_set_channel_id(this_ptr: bigint, val: number): void {
29950 if(!isWasmInitialized) {
29951 throw new Error("initializeWasm() must be awaited first!");
29953 const nativeResponseValue = wasm.TS_TxAddInput_set_channel_id(this_ptr, val);
29954 // debug statements here
29956 // uint64_t TxAddInput_get_serial_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
29958 export function TxAddInput_get_serial_id(this_ptr: bigint): bigint {
29959 if(!isWasmInitialized) {
29960 throw new Error("initializeWasm() must be awaited first!");
29962 const nativeResponseValue = wasm.TS_TxAddInput_get_serial_id(this_ptr);
29963 return nativeResponseValue;
29965 // void TxAddInput_set_serial_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint64_t val);
29967 export function TxAddInput_set_serial_id(this_ptr: bigint, val: bigint): void {
29968 if(!isWasmInitialized) {
29969 throw new Error("initializeWasm() must be awaited first!");
29971 const nativeResponseValue = wasm.TS_TxAddInput_set_serial_id(this_ptr, val);
29972 // debug statements here
29974 // struct LDKTransactionU16LenLimited TxAddInput_get_prevtx(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
29976 export function TxAddInput_get_prevtx(this_ptr: bigint): bigint {
29977 if(!isWasmInitialized) {
29978 throw new Error("initializeWasm() must be awaited first!");
29980 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx(this_ptr);
29981 return nativeResponseValue;
29983 // void TxAddInput_set_prevtx(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKTransactionU16LenLimited val);
29985 export function TxAddInput_set_prevtx(this_ptr: bigint, val: bigint): void {
29986 if(!isWasmInitialized) {
29987 throw new Error("initializeWasm() must be awaited first!");
29989 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx(this_ptr, val);
29990 // debug statements here
29992 // uint32_t TxAddInput_get_prevtx_out(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
29994 export function TxAddInput_get_prevtx_out(this_ptr: bigint): number {
29995 if(!isWasmInitialized) {
29996 throw new Error("initializeWasm() must be awaited first!");
29998 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx_out(this_ptr);
29999 return nativeResponseValue;
30001 // void TxAddInput_set_prevtx_out(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
30003 export function TxAddInput_set_prevtx_out(this_ptr: bigint, val: number): void {
30004 if(!isWasmInitialized) {
30005 throw new Error("initializeWasm() must be awaited first!");
30007 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx_out(this_ptr, val);
30008 // debug statements here
30010 // uint32_t TxAddInput_get_sequence(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
30012 export function TxAddInput_get_sequence(this_ptr: bigint): number {
30013 if(!isWasmInitialized) {
30014 throw new Error("initializeWasm() must be awaited first!");
30016 const nativeResponseValue = wasm.TS_TxAddInput_get_sequence(this_ptr);
30017 return nativeResponseValue;
30019 // void TxAddInput_set_sequence(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
30021 export function TxAddInput_set_sequence(this_ptr: bigint, val: number): void {
30022 if(!isWasmInitialized) {
30023 throw new Error("initializeWasm() must be awaited first!");
30025 const nativeResponseValue = wasm.TS_TxAddInput_set_sequence(this_ptr, val);
30026 // debug statements here
30028 // MUST_USE_RES struct LDKTxAddInput TxAddInput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg, struct LDKTransactionU16LenLimited prevtx_arg, uint32_t prevtx_out_arg, uint32_t sequence_arg);
30030 export function TxAddInput_new(channel_id_arg: number, serial_id_arg: bigint, prevtx_arg: bigint, prevtx_out_arg: number, sequence_arg: number): bigint {
30031 if(!isWasmInitialized) {
30032 throw new Error("initializeWasm() must be awaited first!");
30034 const nativeResponseValue = wasm.TS_TxAddInput_new(channel_id_arg, serial_id_arg, prevtx_arg, prevtx_out_arg, sequence_arg);
30035 return nativeResponseValue;
30037 // uint64_t TxAddInput_clone_ptr(LDKTxAddInput *NONNULL_PTR arg);
30039 export function TxAddInput_clone_ptr(arg: bigint): bigint {
30040 if(!isWasmInitialized) {
30041 throw new Error("initializeWasm() must be awaited first!");
30043 const nativeResponseValue = wasm.TS_TxAddInput_clone_ptr(arg);
30044 return nativeResponseValue;
30046 // struct LDKTxAddInput TxAddInput_clone(const struct LDKTxAddInput *NONNULL_PTR orig);
30048 export function TxAddInput_clone(orig: bigint): bigint {
30049 if(!isWasmInitialized) {
30050 throw new Error("initializeWasm() must be awaited first!");
30052 const nativeResponseValue = wasm.TS_TxAddInput_clone(orig);
30053 return nativeResponseValue;
30055 // bool TxAddInput_eq(const struct LDKTxAddInput *NONNULL_PTR a, const struct LDKTxAddInput *NONNULL_PTR b);
30057 export function TxAddInput_eq(a: bigint, b: bigint): boolean {
30058 if(!isWasmInitialized) {
30059 throw new Error("initializeWasm() must be awaited first!");
30061 const nativeResponseValue = wasm.TS_TxAddInput_eq(a, b);
30062 return nativeResponseValue;
30064 // void TxAddOutput_free(struct LDKTxAddOutput this_obj);
30066 export function TxAddOutput_free(this_obj: bigint): void {
30067 if(!isWasmInitialized) {
30068 throw new Error("initializeWasm() must be awaited first!");
30070 const nativeResponseValue = wasm.TS_TxAddOutput_free(this_obj);
30071 // debug statements here
30073 // const uint8_t (*TxAddOutput_get_channel_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr))[32];
30075 export function TxAddOutput_get_channel_id(this_ptr: bigint): number {
30076 if(!isWasmInitialized) {
30077 throw new Error("initializeWasm() must be awaited first!");
30079 const nativeResponseValue = wasm.TS_TxAddOutput_get_channel_id(this_ptr);
30080 return nativeResponseValue;
30082 // void TxAddOutput_set_channel_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30084 export function TxAddOutput_set_channel_id(this_ptr: bigint, val: number): void {
30085 if(!isWasmInitialized) {
30086 throw new Error("initializeWasm() must be awaited first!");
30088 const nativeResponseValue = wasm.TS_TxAddOutput_set_channel_id(this_ptr, val);
30089 // debug statements here
30091 // uint64_t TxAddOutput_get_serial_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
30093 export function TxAddOutput_get_serial_id(this_ptr: bigint): bigint {
30094 if(!isWasmInitialized) {
30095 throw new Error("initializeWasm() must be awaited first!");
30097 const nativeResponseValue = wasm.TS_TxAddOutput_get_serial_id(this_ptr);
30098 return nativeResponseValue;
30100 // void TxAddOutput_set_serial_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
30102 export function TxAddOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
30103 if(!isWasmInitialized) {
30104 throw new Error("initializeWasm() must be awaited first!");
30106 const nativeResponseValue = wasm.TS_TxAddOutput_set_serial_id(this_ptr, val);
30107 // debug statements here
30109 // uint64_t TxAddOutput_get_sats(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
30111 export function TxAddOutput_get_sats(this_ptr: bigint): bigint {
30112 if(!isWasmInitialized) {
30113 throw new Error("initializeWasm() must be awaited first!");
30115 const nativeResponseValue = wasm.TS_TxAddOutput_get_sats(this_ptr);
30116 return nativeResponseValue;
30118 // void TxAddOutput_set_sats(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
30120 export function TxAddOutput_set_sats(this_ptr: bigint, val: bigint): void {
30121 if(!isWasmInitialized) {
30122 throw new Error("initializeWasm() must be awaited first!");
30124 const nativeResponseValue = wasm.TS_TxAddOutput_set_sats(this_ptr, val);
30125 // debug statements here
30127 // struct LDKu8slice TxAddOutput_get_script(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
30129 export function TxAddOutput_get_script(this_ptr: bigint): number {
30130 if(!isWasmInitialized) {
30131 throw new Error("initializeWasm() must be awaited first!");
30133 const nativeResponseValue = wasm.TS_TxAddOutput_get_script(this_ptr);
30134 return nativeResponseValue;
30136 // void TxAddOutput_set_script(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
30138 export function TxAddOutput_set_script(this_ptr: bigint, val: number): void {
30139 if(!isWasmInitialized) {
30140 throw new Error("initializeWasm() must be awaited first!");
30142 const nativeResponseValue = wasm.TS_TxAddOutput_set_script(this_ptr, val);
30143 // debug statements here
30145 // MUST_USE_RES struct LDKTxAddOutput TxAddOutput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg, uint64_t sats_arg, struct LDKCVec_u8Z script_arg);
30147 export function TxAddOutput_new(channel_id_arg: number, serial_id_arg: bigint, sats_arg: bigint, script_arg: number): bigint {
30148 if(!isWasmInitialized) {
30149 throw new Error("initializeWasm() must be awaited first!");
30151 const nativeResponseValue = wasm.TS_TxAddOutput_new(channel_id_arg, serial_id_arg, sats_arg, script_arg);
30152 return nativeResponseValue;
30154 // uint64_t TxAddOutput_clone_ptr(LDKTxAddOutput *NONNULL_PTR arg);
30156 export function TxAddOutput_clone_ptr(arg: bigint): bigint {
30157 if(!isWasmInitialized) {
30158 throw new Error("initializeWasm() must be awaited first!");
30160 const nativeResponseValue = wasm.TS_TxAddOutput_clone_ptr(arg);
30161 return nativeResponseValue;
30163 // struct LDKTxAddOutput TxAddOutput_clone(const struct LDKTxAddOutput *NONNULL_PTR orig);
30165 export function TxAddOutput_clone(orig: bigint): bigint {
30166 if(!isWasmInitialized) {
30167 throw new Error("initializeWasm() must be awaited first!");
30169 const nativeResponseValue = wasm.TS_TxAddOutput_clone(orig);
30170 return nativeResponseValue;
30172 // bool TxAddOutput_eq(const struct LDKTxAddOutput *NONNULL_PTR a, const struct LDKTxAddOutput *NONNULL_PTR b);
30174 export function TxAddOutput_eq(a: bigint, b: bigint): boolean {
30175 if(!isWasmInitialized) {
30176 throw new Error("initializeWasm() must be awaited first!");
30178 const nativeResponseValue = wasm.TS_TxAddOutput_eq(a, b);
30179 return nativeResponseValue;
30181 // void TxRemoveInput_free(struct LDKTxRemoveInput this_obj);
30183 export function TxRemoveInput_free(this_obj: bigint): void {
30184 if(!isWasmInitialized) {
30185 throw new Error("initializeWasm() must be awaited first!");
30187 const nativeResponseValue = wasm.TS_TxRemoveInput_free(this_obj);
30188 // debug statements here
30190 // const uint8_t (*TxRemoveInput_get_channel_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr))[32];
30192 export function TxRemoveInput_get_channel_id(this_ptr: bigint): number {
30193 if(!isWasmInitialized) {
30194 throw new Error("initializeWasm() must be awaited first!");
30196 const nativeResponseValue = wasm.TS_TxRemoveInput_get_channel_id(this_ptr);
30197 return nativeResponseValue;
30199 // void TxRemoveInput_set_channel_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30201 export function TxRemoveInput_set_channel_id(this_ptr: bigint, val: number): void {
30202 if(!isWasmInitialized) {
30203 throw new Error("initializeWasm() must be awaited first!");
30205 const nativeResponseValue = wasm.TS_TxRemoveInput_set_channel_id(this_ptr, val);
30206 // debug statements here
30208 // uint64_t TxRemoveInput_get_serial_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr);
30210 export function TxRemoveInput_get_serial_id(this_ptr: bigint): bigint {
30211 if(!isWasmInitialized) {
30212 throw new Error("initializeWasm() must be awaited first!");
30214 const nativeResponseValue = wasm.TS_TxRemoveInput_get_serial_id(this_ptr);
30215 return nativeResponseValue;
30217 // void TxRemoveInput_set_serial_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, uint64_t val);
30219 export function TxRemoveInput_set_serial_id(this_ptr: bigint, val: bigint): void {
30220 if(!isWasmInitialized) {
30221 throw new Error("initializeWasm() must be awaited first!");
30223 const nativeResponseValue = wasm.TS_TxRemoveInput_set_serial_id(this_ptr, val);
30224 // debug statements here
30226 // MUST_USE_RES struct LDKTxRemoveInput TxRemoveInput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
30228 export function TxRemoveInput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
30229 if(!isWasmInitialized) {
30230 throw new Error("initializeWasm() must be awaited first!");
30232 const nativeResponseValue = wasm.TS_TxRemoveInput_new(channel_id_arg, serial_id_arg);
30233 return nativeResponseValue;
30235 // uint64_t TxRemoveInput_clone_ptr(LDKTxRemoveInput *NONNULL_PTR arg);
30237 export function TxRemoveInput_clone_ptr(arg: bigint): bigint {
30238 if(!isWasmInitialized) {
30239 throw new Error("initializeWasm() must be awaited first!");
30241 const nativeResponseValue = wasm.TS_TxRemoveInput_clone_ptr(arg);
30242 return nativeResponseValue;
30244 // struct LDKTxRemoveInput TxRemoveInput_clone(const struct LDKTxRemoveInput *NONNULL_PTR orig);
30246 export function TxRemoveInput_clone(orig: bigint): bigint {
30247 if(!isWasmInitialized) {
30248 throw new Error("initializeWasm() must be awaited first!");
30250 const nativeResponseValue = wasm.TS_TxRemoveInput_clone(orig);
30251 return nativeResponseValue;
30253 // bool TxRemoveInput_eq(const struct LDKTxRemoveInput *NONNULL_PTR a, const struct LDKTxRemoveInput *NONNULL_PTR b);
30255 export function TxRemoveInput_eq(a: bigint, b: bigint): boolean {
30256 if(!isWasmInitialized) {
30257 throw new Error("initializeWasm() must be awaited first!");
30259 const nativeResponseValue = wasm.TS_TxRemoveInput_eq(a, b);
30260 return nativeResponseValue;
30262 // void TxRemoveOutput_free(struct LDKTxRemoveOutput this_obj);
30264 export function TxRemoveOutput_free(this_obj: bigint): void {
30265 if(!isWasmInitialized) {
30266 throw new Error("initializeWasm() must be awaited first!");
30268 const nativeResponseValue = wasm.TS_TxRemoveOutput_free(this_obj);
30269 // debug statements here
30271 // const uint8_t (*TxRemoveOutput_get_channel_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr))[32];
30273 export function TxRemoveOutput_get_channel_id(this_ptr: bigint): number {
30274 if(!isWasmInitialized) {
30275 throw new Error("initializeWasm() must be awaited first!");
30277 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_channel_id(this_ptr);
30278 return nativeResponseValue;
30280 // void TxRemoveOutput_set_channel_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30282 export function TxRemoveOutput_set_channel_id(this_ptr: bigint, val: number): void {
30283 if(!isWasmInitialized) {
30284 throw new Error("initializeWasm() must be awaited first!");
30286 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_channel_id(this_ptr, val);
30287 // debug statements here
30289 // uint64_t TxRemoveOutput_get_serial_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr);
30291 export function TxRemoveOutput_get_serial_id(this_ptr: bigint): bigint {
30292 if(!isWasmInitialized) {
30293 throw new Error("initializeWasm() must be awaited first!");
30295 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_serial_id(this_ptr);
30296 return nativeResponseValue;
30298 // void TxRemoveOutput_set_serial_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, uint64_t val);
30300 export function TxRemoveOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
30301 if(!isWasmInitialized) {
30302 throw new Error("initializeWasm() must be awaited first!");
30304 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_serial_id(this_ptr, val);
30305 // debug statements here
30307 // MUST_USE_RES struct LDKTxRemoveOutput TxRemoveOutput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
30309 export function TxRemoveOutput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
30310 if(!isWasmInitialized) {
30311 throw new Error("initializeWasm() must be awaited first!");
30313 const nativeResponseValue = wasm.TS_TxRemoveOutput_new(channel_id_arg, serial_id_arg);
30314 return nativeResponseValue;
30316 // uint64_t TxRemoveOutput_clone_ptr(LDKTxRemoveOutput *NONNULL_PTR arg);
30318 export function TxRemoveOutput_clone_ptr(arg: bigint): bigint {
30319 if(!isWasmInitialized) {
30320 throw new Error("initializeWasm() must be awaited first!");
30322 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone_ptr(arg);
30323 return nativeResponseValue;
30325 // struct LDKTxRemoveOutput TxRemoveOutput_clone(const struct LDKTxRemoveOutput *NONNULL_PTR orig);
30327 export function TxRemoveOutput_clone(orig: bigint): bigint {
30328 if(!isWasmInitialized) {
30329 throw new Error("initializeWasm() must be awaited first!");
30331 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone(orig);
30332 return nativeResponseValue;
30334 // bool TxRemoveOutput_eq(const struct LDKTxRemoveOutput *NONNULL_PTR a, const struct LDKTxRemoveOutput *NONNULL_PTR b);
30336 export function TxRemoveOutput_eq(a: bigint, b: bigint): boolean {
30337 if(!isWasmInitialized) {
30338 throw new Error("initializeWasm() must be awaited first!");
30340 const nativeResponseValue = wasm.TS_TxRemoveOutput_eq(a, b);
30341 return nativeResponseValue;
30343 // void TxComplete_free(struct LDKTxComplete this_obj);
30345 export function TxComplete_free(this_obj: bigint): void {
30346 if(!isWasmInitialized) {
30347 throw new Error("initializeWasm() must be awaited first!");
30349 const nativeResponseValue = wasm.TS_TxComplete_free(this_obj);
30350 // debug statements here
30352 // const uint8_t (*TxComplete_get_channel_id(const struct LDKTxComplete *NONNULL_PTR this_ptr))[32];
30354 export function TxComplete_get_channel_id(this_ptr: bigint): number {
30355 if(!isWasmInitialized) {
30356 throw new Error("initializeWasm() must be awaited first!");
30358 const nativeResponseValue = wasm.TS_TxComplete_get_channel_id(this_ptr);
30359 return nativeResponseValue;
30361 // void TxComplete_set_channel_id(struct LDKTxComplete *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30363 export function TxComplete_set_channel_id(this_ptr: bigint, val: number): void {
30364 if(!isWasmInitialized) {
30365 throw new Error("initializeWasm() must be awaited first!");
30367 const nativeResponseValue = wasm.TS_TxComplete_set_channel_id(this_ptr, val);
30368 // debug statements here
30370 // MUST_USE_RES struct LDKTxComplete TxComplete_new(struct LDKThirtyTwoBytes channel_id_arg);
30372 export function TxComplete_new(channel_id_arg: number): bigint {
30373 if(!isWasmInitialized) {
30374 throw new Error("initializeWasm() must be awaited first!");
30376 const nativeResponseValue = wasm.TS_TxComplete_new(channel_id_arg);
30377 return nativeResponseValue;
30379 // uint64_t TxComplete_clone_ptr(LDKTxComplete *NONNULL_PTR arg);
30381 export function TxComplete_clone_ptr(arg: bigint): bigint {
30382 if(!isWasmInitialized) {
30383 throw new Error("initializeWasm() must be awaited first!");
30385 const nativeResponseValue = wasm.TS_TxComplete_clone_ptr(arg);
30386 return nativeResponseValue;
30388 // struct LDKTxComplete TxComplete_clone(const struct LDKTxComplete *NONNULL_PTR orig);
30390 export function TxComplete_clone(orig: bigint): bigint {
30391 if(!isWasmInitialized) {
30392 throw new Error("initializeWasm() must be awaited first!");
30394 const nativeResponseValue = wasm.TS_TxComplete_clone(orig);
30395 return nativeResponseValue;
30397 // bool TxComplete_eq(const struct LDKTxComplete *NONNULL_PTR a, const struct LDKTxComplete *NONNULL_PTR b);
30399 export function TxComplete_eq(a: bigint, b: bigint): boolean {
30400 if(!isWasmInitialized) {
30401 throw new Error("initializeWasm() must be awaited first!");
30403 const nativeResponseValue = wasm.TS_TxComplete_eq(a, b);
30404 return nativeResponseValue;
30406 // void TxSignatures_free(struct LDKTxSignatures this_obj);
30408 export function TxSignatures_free(this_obj: bigint): void {
30409 if(!isWasmInitialized) {
30410 throw new Error("initializeWasm() must be awaited first!");
30412 const nativeResponseValue = wasm.TS_TxSignatures_free(this_obj);
30413 // debug statements here
30415 // const uint8_t (*TxSignatures_get_channel_id(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
30417 export function TxSignatures_get_channel_id(this_ptr: bigint): number {
30418 if(!isWasmInitialized) {
30419 throw new Error("initializeWasm() must be awaited first!");
30421 const nativeResponseValue = wasm.TS_TxSignatures_get_channel_id(this_ptr);
30422 return nativeResponseValue;
30424 // void TxSignatures_set_channel_id(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30426 export function TxSignatures_set_channel_id(this_ptr: bigint, val: number): void {
30427 if(!isWasmInitialized) {
30428 throw new Error("initializeWasm() must be awaited first!");
30430 const nativeResponseValue = wasm.TS_TxSignatures_set_channel_id(this_ptr, val);
30431 // debug statements here
30433 // const uint8_t (*TxSignatures_get_tx_hash(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
30435 export function TxSignatures_get_tx_hash(this_ptr: bigint): number {
30436 if(!isWasmInitialized) {
30437 throw new Error("initializeWasm() must be awaited first!");
30439 const nativeResponseValue = wasm.TS_TxSignatures_get_tx_hash(this_ptr);
30440 return nativeResponseValue;
30442 // void TxSignatures_set_tx_hash(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30444 export function TxSignatures_set_tx_hash(this_ptr: bigint, val: number): void {
30445 if(!isWasmInitialized) {
30446 throw new Error("initializeWasm() must be awaited first!");
30448 const nativeResponseValue = wasm.TS_TxSignatures_set_tx_hash(this_ptr, val);
30449 // debug statements here
30451 // struct LDKCVec_WitnessZ TxSignatures_get_witnesses(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
30453 export function TxSignatures_get_witnesses(this_ptr: bigint): number {
30454 if(!isWasmInitialized) {
30455 throw new Error("initializeWasm() must be awaited first!");
30457 const nativeResponseValue = wasm.TS_TxSignatures_get_witnesses(this_ptr);
30458 return nativeResponseValue;
30460 // void TxSignatures_set_witnesses(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKCVec_WitnessZ val);
30462 export function TxSignatures_set_witnesses(this_ptr: bigint, val: number): void {
30463 if(!isWasmInitialized) {
30464 throw new Error("initializeWasm() must be awaited first!");
30466 const nativeResponseValue = wasm.TS_TxSignatures_set_witnesses(this_ptr, val);
30467 // debug statements here
30469 // MUST_USE_RES struct LDKTxSignatures TxSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes tx_hash_arg, struct LDKCVec_WitnessZ witnesses_arg);
30471 export function TxSignatures_new(channel_id_arg: number, tx_hash_arg: number, witnesses_arg: number): bigint {
30472 if(!isWasmInitialized) {
30473 throw new Error("initializeWasm() must be awaited first!");
30475 const nativeResponseValue = wasm.TS_TxSignatures_new(channel_id_arg, tx_hash_arg, witnesses_arg);
30476 return nativeResponseValue;
30478 // uint64_t TxSignatures_clone_ptr(LDKTxSignatures *NONNULL_PTR arg);
30480 export function TxSignatures_clone_ptr(arg: bigint): bigint {
30481 if(!isWasmInitialized) {
30482 throw new Error("initializeWasm() must be awaited first!");
30484 const nativeResponseValue = wasm.TS_TxSignatures_clone_ptr(arg);
30485 return nativeResponseValue;
30487 // struct LDKTxSignatures TxSignatures_clone(const struct LDKTxSignatures *NONNULL_PTR orig);
30489 export function TxSignatures_clone(orig: bigint): bigint {
30490 if(!isWasmInitialized) {
30491 throw new Error("initializeWasm() must be awaited first!");
30493 const nativeResponseValue = wasm.TS_TxSignatures_clone(orig);
30494 return nativeResponseValue;
30496 // bool TxSignatures_eq(const struct LDKTxSignatures *NONNULL_PTR a, const struct LDKTxSignatures *NONNULL_PTR b);
30498 export function TxSignatures_eq(a: bigint, b: bigint): boolean {
30499 if(!isWasmInitialized) {
30500 throw new Error("initializeWasm() must be awaited first!");
30502 const nativeResponseValue = wasm.TS_TxSignatures_eq(a, b);
30503 return nativeResponseValue;
30505 // void TxInitRbf_free(struct LDKTxInitRbf this_obj);
30507 export function TxInitRbf_free(this_obj: bigint): void {
30508 if(!isWasmInitialized) {
30509 throw new Error("initializeWasm() must be awaited first!");
30511 const nativeResponseValue = wasm.TS_TxInitRbf_free(this_obj);
30512 // debug statements here
30514 // const uint8_t (*TxInitRbf_get_channel_id(const struct LDKTxInitRbf *NONNULL_PTR this_ptr))[32];
30516 export function TxInitRbf_get_channel_id(this_ptr: bigint): number {
30517 if(!isWasmInitialized) {
30518 throw new Error("initializeWasm() must be awaited first!");
30520 const nativeResponseValue = wasm.TS_TxInitRbf_get_channel_id(this_ptr);
30521 return nativeResponseValue;
30523 // void TxInitRbf_set_channel_id(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30525 export function TxInitRbf_set_channel_id(this_ptr: bigint, val: number): void {
30526 if(!isWasmInitialized) {
30527 throw new Error("initializeWasm() must be awaited first!");
30529 const nativeResponseValue = wasm.TS_TxInitRbf_set_channel_id(this_ptr, val);
30530 // debug statements here
30532 // uint32_t TxInitRbf_get_locktime(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
30534 export function TxInitRbf_get_locktime(this_ptr: bigint): number {
30535 if(!isWasmInitialized) {
30536 throw new Error("initializeWasm() must be awaited first!");
30538 const nativeResponseValue = wasm.TS_TxInitRbf_get_locktime(this_ptr);
30539 return nativeResponseValue;
30541 // void TxInitRbf_set_locktime(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
30543 export function TxInitRbf_set_locktime(this_ptr: bigint, val: number): void {
30544 if(!isWasmInitialized) {
30545 throw new Error("initializeWasm() must be awaited first!");
30547 const nativeResponseValue = wasm.TS_TxInitRbf_set_locktime(this_ptr, val);
30548 // debug statements here
30550 // uint32_t TxInitRbf_get_feerate_sat_per_1000_weight(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
30552 export function TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: bigint): number {
30553 if(!isWasmInitialized) {
30554 throw new Error("initializeWasm() must be awaited first!");
30556 const nativeResponseValue = wasm.TS_TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr);
30557 return nativeResponseValue;
30559 // void TxInitRbf_set_feerate_sat_per_1000_weight(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
30561 export function TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
30562 if(!isWasmInitialized) {
30563 throw new Error("initializeWasm() must be awaited first!");
30565 const nativeResponseValue = wasm.TS_TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr, val);
30566 // debug statements here
30568 // struct LDKCOption_i64Z TxInitRbf_get_funding_output_contribution(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
30570 export function TxInitRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
30571 if(!isWasmInitialized) {
30572 throw new Error("initializeWasm() must be awaited first!");
30574 const nativeResponseValue = wasm.TS_TxInitRbf_get_funding_output_contribution(this_ptr);
30575 return nativeResponseValue;
30577 // void TxInitRbf_set_funding_output_contribution(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
30579 export function TxInitRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
30580 if(!isWasmInitialized) {
30581 throw new Error("initializeWasm() must be awaited first!");
30583 const nativeResponseValue = wasm.TS_TxInitRbf_set_funding_output_contribution(this_ptr, val);
30584 // debug statements here
30586 // MUST_USE_RES struct LDKTxInitRbf TxInitRbf_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t locktime_arg, uint32_t feerate_sat_per_1000_weight_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
30588 export function TxInitRbf_new(channel_id_arg: number, locktime_arg: number, feerate_sat_per_1000_weight_arg: number, funding_output_contribution_arg: bigint): bigint {
30589 if(!isWasmInitialized) {
30590 throw new Error("initializeWasm() must be awaited first!");
30592 const nativeResponseValue = wasm.TS_TxInitRbf_new(channel_id_arg, locktime_arg, feerate_sat_per_1000_weight_arg, funding_output_contribution_arg);
30593 return nativeResponseValue;
30595 // uint64_t TxInitRbf_clone_ptr(LDKTxInitRbf *NONNULL_PTR arg);
30597 export function TxInitRbf_clone_ptr(arg: bigint): bigint {
30598 if(!isWasmInitialized) {
30599 throw new Error("initializeWasm() must be awaited first!");
30601 const nativeResponseValue = wasm.TS_TxInitRbf_clone_ptr(arg);
30602 return nativeResponseValue;
30604 // struct LDKTxInitRbf TxInitRbf_clone(const struct LDKTxInitRbf *NONNULL_PTR orig);
30606 export function TxInitRbf_clone(orig: bigint): bigint {
30607 if(!isWasmInitialized) {
30608 throw new Error("initializeWasm() must be awaited first!");
30610 const nativeResponseValue = wasm.TS_TxInitRbf_clone(orig);
30611 return nativeResponseValue;
30613 // bool TxInitRbf_eq(const struct LDKTxInitRbf *NONNULL_PTR a, const struct LDKTxInitRbf *NONNULL_PTR b);
30615 export function TxInitRbf_eq(a: bigint, b: bigint): boolean {
30616 if(!isWasmInitialized) {
30617 throw new Error("initializeWasm() must be awaited first!");
30619 const nativeResponseValue = wasm.TS_TxInitRbf_eq(a, b);
30620 return nativeResponseValue;
30622 // void TxAckRbf_free(struct LDKTxAckRbf this_obj);
30624 export function TxAckRbf_free(this_obj: bigint): void {
30625 if(!isWasmInitialized) {
30626 throw new Error("initializeWasm() must be awaited first!");
30628 const nativeResponseValue = wasm.TS_TxAckRbf_free(this_obj);
30629 // debug statements here
30631 // const uint8_t (*TxAckRbf_get_channel_id(const struct LDKTxAckRbf *NONNULL_PTR this_ptr))[32];
30633 export function TxAckRbf_get_channel_id(this_ptr: bigint): number {
30634 if(!isWasmInitialized) {
30635 throw new Error("initializeWasm() must be awaited first!");
30637 const nativeResponseValue = wasm.TS_TxAckRbf_get_channel_id(this_ptr);
30638 return nativeResponseValue;
30640 // void TxAckRbf_set_channel_id(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30642 export function TxAckRbf_set_channel_id(this_ptr: bigint, val: number): void {
30643 if(!isWasmInitialized) {
30644 throw new Error("initializeWasm() must be awaited first!");
30646 const nativeResponseValue = wasm.TS_TxAckRbf_set_channel_id(this_ptr, val);
30647 // debug statements here
30649 // struct LDKCOption_i64Z TxAckRbf_get_funding_output_contribution(const struct LDKTxAckRbf *NONNULL_PTR this_ptr);
30651 export function TxAckRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
30652 if(!isWasmInitialized) {
30653 throw new Error("initializeWasm() must be awaited first!");
30655 const nativeResponseValue = wasm.TS_TxAckRbf_get_funding_output_contribution(this_ptr);
30656 return nativeResponseValue;
30658 // void TxAckRbf_set_funding_output_contribution(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
30660 export function TxAckRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
30661 if(!isWasmInitialized) {
30662 throw new Error("initializeWasm() must be awaited first!");
30664 const nativeResponseValue = wasm.TS_TxAckRbf_set_funding_output_contribution(this_ptr, val);
30665 // debug statements here
30667 // MUST_USE_RES struct LDKTxAckRbf TxAckRbf_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
30669 export function TxAckRbf_new(channel_id_arg: number, funding_output_contribution_arg: bigint): bigint {
30670 if(!isWasmInitialized) {
30671 throw new Error("initializeWasm() must be awaited first!");
30673 const nativeResponseValue = wasm.TS_TxAckRbf_new(channel_id_arg, funding_output_contribution_arg);
30674 return nativeResponseValue;
30676 // uint64_t TxAckRbf_clone_ptr(LDKTxAckRbf *NONNULL_PTR arg);
30678 export function TxAckRbf_clone_ptr(arg: bigint): bigint {
30679 if(!isWasmInitialized) {
30680 throw new Error("initializeWasm() must be awaited first!");
30682 const nativeResponseValue = wasm.TS_TxAckRbf_clone_ptr(arg);
30683 return nativeResponseValue;
30685 // struct LDKTxAckRbf TxAckRbf_clone(const struct LDKTxAckRbf *NONNULL_PTR orig);
30687 export function TxAckRbf_clone(orig: bigint): bigint {
30688 if(!isWasmInitialized) {
30689 throw new Error("initializeWasm() must be awaited first!");
30691 const nativeResponseValue = wasm.TS_TxAckRbf_clone(orig);
30692 return nativeResponseValue;
30694 // bool TxAckRbf_eq(const struct LDKTxAckRbf *NONNULL_PTR a, const struct LDKTxAckRbf *NONNULL_PTR b);
30696 export function TxAckRbf_eq(a: bigint, b: bigint): boolean {
30697 if(!isWasmInitialized) {
30698 throw new Error("initializeWasm() must be awaited first!");
30700 const nativeResponseValue = wasm.TS_TxAckRbf_eq(a, b);
30701 return nativeResponseValue;
30703 // void TxAbort_free(struct LDKTxAbort this_obj);
30705 export function TxAbort_free(this_obj: bigint): void {
30706 if(!isWasmInitialized) {
30707 throw new Error("initializeWasm() must be awaited first!");
30709 const nativeResponseValue = wasm.TS_TxAbort_free(this_obj);
30710 // debug statements here
30712 // const uint8_t (*TxAbort_get_channel_id(const struct LDKTxAbort *NONNULL_PTR this_ptr))[32];
30714 export function TxAbort_get_channel_id(this_ptr: bigint): number {
30715 if(!isWasmInitialized) {
30716 throw new Error("initializeWasm() must be awaited first!");
30718 const nativeResponseValue = wasm.TS_TxAbort_get_channel_id(this_ptr);
30719 return nativeResponseValue;
30721 // void TxAbort_set_channel_id(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30723 export function TxAbort_set_channel_id(this_ptr: bigint, val: number): void {
30724 if(!isWasmInitialized) {
30725 throw new Error("initializeWasm() must be awaited first!");
30727 const nativeResponseValue = wasm.TS_TxAbort_set_channel_id(this_ptr, val);
30728 // debug statements here
30730 // struct LDKCVec_u8Z TxAbort_get_data(const struct LDKTxAbort *NONNULL_PTR this_ptr);
30732 export function TxAbort_get_data(this_ptr: bigint): number {
30733 if(!isWasmInitialized) {
30734 throw new Error("initializeWasm() must be awaited first!");
30736 const nativeResponseValue = wasm.TS_TxAbort_get_data(this_ptr);
30737 return nativeResponseValue;
30739 // void TxAbort_set_data(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
30741 export function TxAbort_set_data(this_ptr: bigint, val: number): void {
30742 if(!isWasmInitialized) {
30743 throw new Error("initializeWasm() must be awaited first!");
30745 const nativeResponseValue = wasm.TS_TxAbort_set_data(this_ptr, val);
30746 // debug statements here
30748 // MUST_USE_RES struct LDKTxAbort TxAbort_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z data_arg);
30750 export function TxAbort_new(channel_id_arg: number, data_arg: number): bigint {
30751 if(!isWasmInitialized) {
30752 throw new Error("initializeWasm() must be awaited first!");
30754 const nativeResponseValue = wasm.TS_TxAbort_new(channel_id_arg, data_arg);
30755 return nativeResponseValue;
30757 // uint64_t TxAbort_clone_ptr(LDKTxAbort *NONNULL_PTR arg);
30759 export function TxAbort_clone_ptr(arg: bigint): bigint {
30760 if(!isWasmInitialized) {
30761 throw new Error("initializeWasm() must be awaited first!");
30763 const nativeResponseValue = wasm.TS_TxAbort_clone_ptr(arg);
30764 return nativeResponseValue;
30766 // struct LDKTxAbort TxAbort_clone(const struct LDKTxAbort *NONNULL_PTR orig);
30768 export function TxAbort_clone(orig: bigint): bigint {
30769 if(!isWasmInitialized) {
30770 throw new Error("initializeWasm() must be awaited first!");
30772 const nativeResponseValue = wasm.TS_TxAbort_clone(orig);
30773 return nativeResponseValue;
30775 // bool TxAbort_eq(const struct LDKTxAbort *NONNULL_PTR a, const struct LDKTxAbort *NONNULL_PTR b);
30777 export function TxAbort_eq(a: bigint, b: bigint): boolean {
30778 if(!isWasmInitialized) {
30779 throw new Error("initializeWasm() must be awaited first!");
30781 const nativeResponseValue = wasm.TS_TxAbort_eq(a, b);
30782 return nativeResponseValue;
30784 // void Shutdown_free(struct LDKShutdown this_obj);
30786 export function Shutdown_free(this_obj: bigint): void {
30787 if(!isWasmInitialized) {
30788 throw new Error("initializeWasm() must be awaited first!");
30790 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
30791 // debug statements here
30793 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
30795 export function Shutdown_get_channel_id(this_ptr: bigint): number {
30796 if(!isWasmInitialized) {
30797 throw new Error("initializeWasm() must be awaited first!");
30799 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
30800 return nativeResponseValue;
30802 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30804 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
30805 if(!isWasmInitialized) {
30806 throw new Error("initializeWasm() must be awaited first!");
30808 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
30809 // debug statements here
30811 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
30813 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
30814 if(!isWasmInitialized) {
30815 throw new Error("initializeWasm() must be awaited first!");
30817 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
30818 return nativeResponseValue;
30820 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
30822 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
30823 if(!isWasmInitialized) {
30824 throw new Error("initializeWasm() must be awaited first!");
30826 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
30827 // debug statements here
30829 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
30831 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
30832 if(!isWasmInitialized) {
30833 throw new Error("initializeWasm() must be awaited first!");
30835 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
30836 return nativeResponseValue;
30838 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
30840 export function Shutdown_clone_ptr(arg: bigint): bigint {
30841 if(!isWasmInitialized) {
30842 throw new Error("initializeWasm() must be awaited first!");
30844 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
30845 return nativeResponseValue;
30847 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
30849 export function Shutdown_clone(orig: bigint): bigint {
30850 if(!isWasmInitialized) {
30851 throw new Error("initializeWasm() must be awaited first!");
30853 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
30854 return nativeResponseValue;
30856 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
30858 export function Shutdown_eq(a: bigint, b: bigint): boolean {
30859 if(!isWasmInitialized) {
30860 throw new Error("initializeWasm() must be awaited first!");
30862 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
30863 return nativeResponseValue;
30865 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
30867 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
30868 if(!isWasmInitialized) {
30869 throw new Error("initializeWasm() must be awaited first!");
30871 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
30872 // debug statements here
30874 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
30876 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
30877 if(!isWasmInitialized) {
30878 throw new Error("initializeWasm() must be awaited first!");
30880 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
30881 return nativeResponseValue;
30883 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
30885 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
30886 if(!isWasmInitialized) {
30887 throw new Error("initializeWasm() must be awaited first!");
30889 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
30890 // debug statements here
30892 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
30894 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
30895 if(!isWasmInitialized) {
30896 throw new Error("initializeWasm() must be awaited first!");
30898 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
30899 return nativeResponseValue;
30901 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
30903 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
30904 if(!isWasmInitialized) {
30905 throw new Error("initializeWasm() must be awaited first!");
30907 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
30908 // debug statements here
30910 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
30912 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
30913 if(!isWasmInitialized) {
30914 throw new Error("initializeWasm() must be awaited first!");
30916 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
30917 return nativeResponseValue;
30919 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
30921 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
30922 if(!isWasmInitialized) {
30923 throw new Error("initializeWasm() must be awaited first!");
30925 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
30926 return nativeResponseValue;
30928 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
30930 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
30931 if(!isWasmInitialized) {
30932 throw new Error("initializeWasm() must be awaited first!");
30934 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
30935 return nativeResponseValue;
30937 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
30939 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
30940 if(!isWasmInitialized) {
30941 throw new Error("initializeWasm() must be awaited first!");
30943 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
30944 return nativeResponseValue;
30946 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
30948 export function ClosingSigned_free(this_obj: bigint): void {
30949 if(!isWasmInitialized) {
30950 throw new Error("initializeWasm() must be awaited first!");
30952 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
30953 // debug statements here
30955 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
30957 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
30958 if(!isWasmInitialized) {
30959 throw new Error("initializeWasm() must be awaited first!");
30961 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
30962 return nativeResponseValue;
30964 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30966 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
30967 if(!isWasmInitialized) {
30968 throw new Error("initializeWasm() must be awaited first!");
30970 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
30971 // debug statements here
30973 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
30975 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
30976 if(!isWasmInitialized) {
30977 throw new Error("initializeWasm() must be awaited first!");
30979 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
30980 return nativeResponseValue;
30982 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
30984 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
30985 if(!isWasmInitialized) {
30986 throw new Error("initializeWasm() must be awaited first!");
30988 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
30989 // debug statements here
30991 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
30993 export function ClosingSigned_get_signature(this_ptr: bigint): number {
30994 if(!isWasmInitialized) {
30995 throw new Error("initializeWasm() must be awaited first!");
30997 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
30998 return nativeResponseValue;
31000 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
31002 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
31003 if(!isWasmInitialized) {
31004 throw new Error("initializeWasm() must be awaited first!");
31006 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
31007 // debug statements here
31009 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
31011 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
31012 if(!isWasmInitialized) {
31013 throw new Error("initializeWasm() must be awaited first!");
31015 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
31016 return nativeResponseValue;
31018 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
31020 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
31021 if(!isWasmInitialized) {
31022 throw new Error("initializeWasm() must be awaited first!");
31024 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
31025 // debug statements here
31027 // 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);
31029 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
31030 if(!isWasmInitialized) {
31031 throw new Error("initializeWasm() must be awaited first!");
31033 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
31034 return nativeResponseValue;
31036 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
31038 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
31039 if(!isWasmInitialized) {
31040 throw new Error("initializeWasm() must be awaited first!");
31042 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
31043 return nativeResponseValue;
31045 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
31047 export function ClosingSigned_clone(orig: bigint): bigint {
31048 if(!isWasmInitialized) {
31049 throw new Error("initializeWasm() must be awaited first!");
31051 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
31052 return nativeResponseValue;
31054 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
31056 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
31057 if(!isWasmInitialized) {
31058 throw new Error("initializeWasm() must be awaited first!");
31060 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
31061 return nativeResponseValue;
31063 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
31065 export function UpdateAddHTLC_free(this_obj: bigint): void {
31066 if(!isWasmInitialized) {
31067 throw new Error("initializeWasm() must be awaited first!");
31069 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
31070 // debug statements here
31072 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
31074 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
31075 if(!isWasmInitialized) {
31076 throw new Error("initializeWasm() must be awaited first!");
31078 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
31079 return nativeResponseValue;
31081 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31083 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
31084 if(!isWasmInitialized) {
31085 throw new Error("initializeWasm() must be awaited first!");
31087 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
31088 // debug statements here
31090 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
31092 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
31093 if(!isWasmInitialized) {
31094 throw new Error("initializeWasm() must be awaited first!");
31096 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
31097 return nativeResponseValue;
31099 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
31101 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
31102 if(!isWasmInitialized) {
31103 throw new Error("initializeWasm() must be awaited first!");
31105 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
31106 // debug statements here
31108 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
31110 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
31111 if(!isWasmInitialized) {
31112 throw new Error("initializeWasm() must be awaited first!");
31114 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
31115 return nativeResponseValue;
31117 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
31119 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
31120 if(!isWasmInitialized) {
31121 throw new Error("initializeWasm() must be awaited first!");
31123 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
31124 // debug statements here
31126 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
31128 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
31129 if(!isWasmInitialized) {
31130 throw new Error("initializeWasm() must be awaited first!");
31132 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
31133 return nativeResponseValue;
31135 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31137 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
31138 if(!isWasmInitialized) {
31139 throw new Error("initializeWasm() must be awaited first!");
31141 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
31142 // debug statements here
31144 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
31146 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
31147 if(!isWasmInitialized) {
31148 throw new Error("initializeWasm() must be awaited first!");
31150 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
31151 return nativeResponseValue;
31153 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
31155 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
31156 if(!isWasmInitialized) {
31157 throw new Error("initializeWasm() must be awaited first!");
31159 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
31160 // debug statements here
31162 // struct LDKCOption_u64Z UpdateAddHTLC_get_skimmed_fee_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
31164 export function UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: bigint): bigint {
31165 if(!isWasmInitialized) {
31166 throw new Error("initializeWasm() must be awaited first!");
31168 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_skimmed_fee_msat(this_ptr);
31169 return nativeResponseValue;
31171 // void UpdateAddHTLC_set_skimmed_fee_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31173 export function UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
31174 if(!isWasmInitialized) {
31175 throw new Error("initializeWasm() must be awaited first!");
31177 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_skimmed_fee_msat(this_ptr, val);
31178 // debug statements here
31180 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
31182 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
31183 if(!isWasmInitialized) {
31184 throw new Error("initializeWasm() must be awaited first!");
31186 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
31187 return nativeResponseValue;
31189 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
31191 export function UpdateAddHTLC_clone(orig: bigint): bigint {
31192 if(!isWasmInitialized) {
31193 throw new Error("initializeWasm() must be awaited first!");
31195 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
31196 return nativeResponseValue;
31198 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
31200 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
31201 if(!isWasmInitialized) {
31202 throw new Error("initializeWasm() must be awaited first!");
31204 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
31205 return nativeResponseValue;
31207 // void OnionMessage_free(struct LDKOnionMessage this_obj);
31209 export function OnionMessage_free(this_obj: bigint): void {
31210 if(!isWasmInitialized) {
31211 throw new Error("initializeWasm() must be awaited first!");
31213 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
31214 // debug statements here
31216 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
31218 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
31219 if(!isWasmInitialized) {
31220 throw new Error("initializeWasm() must be awaited first!");
31222 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
31223 return nativeResponseValue;
31225 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31227 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
31228 if(!isWasmInitialized) {
31229 throw new Error("initializeWasm() must be awaited first!");
31231 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
31232 // debug statements here
31234 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
31236 export function OnionMessage_clone_ptr(arg: bigint): bigint {
31237 if(!isWasmInitialized) {
31238 throw new Error("initializeWasm() must be awaited first!");
31240 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
31241 return nativeResponseValue;
31243 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
31245 export function OnionMessage_clone(orig: bigint): bigint {
31246 if(!isWasmInitialized) {
31247 throw new Error("initializeWasm() must be awaited first!");
31249 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
31250 return nativeResponseValue;
31252 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
31254 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
31255 if(!isWasmInitialized) {
31256 throw new Error("initializeWasm() must be awaited first!");
31258 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
31259 return nativeResponseValue;
31261 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
31263 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
31264 if(!isWasmInitialized) {
31265 throw new Error("initializeWasm() must be awaited first!");
31267 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
31268 // debug statements here
31270 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
31272 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
31273 if(!isWasmInitialized) {
31274 throw new Error("initializeWasm() must be awaited first!");
31276 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
31277 return nativeResponseValue;
31279 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31281 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
31282 if(!isWasmInitialized) {
31283 throw new Error("initializeWasm() must be awaited first!");
31285 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
31286 // debug statements here
31288 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
31290 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
31291 if(!isWasmInitialized) {
31292 throw new Error("initializeWasm() must be awaited first!");
31294 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
31295 return nativeResponseValue;
31297 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
31299 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
31300 if(!isWasmInitialized) {
31301 throw new Error("initializeWasm() must be awaited first!");
31303 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
31304 // debug statements here
31306 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
31308 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
31309 if(!isWasmInitialized) {
31310 throw new Error("initializeWasm() must be awaited first!");
31312 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
31313 return nativeResponseValue;
31315 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31317 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
31318 if(!isWasmInitialized) {
31319 throw new Error("initializeWasm() must be awaited first!");
31321 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
31322 // debug statements here
31324 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
31326 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
31327 if(!isWasmInitialized) {
31328 throw new Error("initializeWasm() must be awaited first!");
31330 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
31331 return nativeResponseValue;
31333 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
31335 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
31336 if(!isWasmInitialized) {
31337 throw new Error("initializeWasm() must be awaited first!");
31339 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
31340 return nativeResponseValue;
31342 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
31344 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
31345 if(!isWasmInitialized) {
31346 throw new Error("initializeWasm() must be awaited first!");
31348 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
31349 return nativeResponseValue;
31351 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
31353 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
31354 if(!isWasmInitialized) {
31355 throw new Error("initializeWasm() must be awaited first!");
31357 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
31358 return nativeResponseValue;
31360 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
31362 export function UpdateFailHTLC_free(this_obj: bigint): void {
31363 if(!isWasmInitialized) {
31364 throw new Error("initializeWasm() must be awaited first!");
31366 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
31367 // debug statements here
31369 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
31371 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
31372 if(!isWasmInitialized) {
31373 throw new Error("initializeWasm() must be awaited first!");
31375 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
31376 return nativeResponseValue;
31378 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31380 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
31381 if(!isWasmInitialized) {
31382 throw new Error("initializeWasm() must be awaited first!");
31384 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
31385 // debug statements here
31387 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
31389 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
31390 if(!isWasmInitialized) {
31391 throw new Error("initializeWasm() must be awaited first!");
31393 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
31394 return nativeResponseValue;
31396 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
31398 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
31399 if(!isWasmInitialized) {
31400 throw new Error("initializeWasm() must be awaited first!");
31402 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
31403 // debug statements here
31405 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
31407 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
31408 if(!isWasmInitialized) {
31409 throw new Error("initializeWasm() must be awaited first!");
31411 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
31412 return nativeResponseValue;
31414 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
31416 export function UpdateFailHTLC_clone(orig: bigint): bigint {
31417 if(!isWasmInitialized) {
31418 throw new Error("initializeWasm() must be awaited first!");
31420 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
31421 return nativeResponseValue;
31423 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
31425 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
31426 if(!isWasmInitialized) {
31427 throw new Error("initializeWasm() must be awaited first!");
31429 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
31430 return nativeResponseValue;
31432 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
31434 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
31435 if(!isWasmInitialized) {
31436 throw new Error("initializeWasm() must be awaited first!");
31438 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
31439 // debug statements here
31441 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
31443 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
31444 if(!isWasmInitialized) {
31445 throw new Error("initializeWasm() must be awaited first!");
31447 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
31448 return nativeResponseValue;
31450 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31452 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
31453 if(!isWasmInitialized) {
31454 throw new Error("initializeWasm() must be awaited first!");
31456 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
31457 // debug statements here
31459 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
31461 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
31462 if(!isWasmInitialized) {
31463 throw new Error("initializeWasm() must be awaited first!");
31465 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
31466 return nativeResponseValue;
31468 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
31470 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
31471 if(!isWasmInitialized) {
31472 throw new Error("initializeWasm() must be awaited first!");
31474 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
31475 // debug statements here
31477 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
31479 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
31480 if(!isWasmInitialized) {
31481 throw new Error("initializeWasm() must be awaited first!");
31483 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
31484 return nativeResponseValue;
31486 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
31488 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
31489 if(!isWasmInitialized) {
31490 throw new Error("initializeWasm() must be awaited first!");
31492 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
31493 // debug statements here
31495 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
31497 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
31498 if(!isWasmInitialized) {
31499 throw new Error("initializeWasm() must be awaited first!");
31501 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
31502 return nativeResponseValue;
31504 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
31506 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
31507 if(!isWasmInitialized) {
31508 throw new Error("initializeWasm() must be awaited first!");
31510 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
31511 return nativeResponseValue;
31513 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
31515 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
31516 if(!isWasmInitialized) {
31517 throw new Error("initializeWasm() must be awaited first!");
31519 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
31520 return nativeResponseValue;
31522 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
31524 export function CommitmentSigned_free(this_obj: bigint): void {
31525 if(!isWasmInitialized) {
31526 throw new Error("initializeWasm() must be awaited first!");
31528 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
31529 // debug statements here
31531 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
31533 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
31534 if(!isWasmInitialized) {
31535 throw new Error("initializeWasm() must be awaited first!");
31537 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
31538 return nativeResponseValue;
31540 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31542 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
31543 if(!isWasmInitialized) {
31544 throw new Error("initializeWasm() must be awaited first!");
31546 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
31547 // debug statements here
31549 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
31551 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
31552 if(!isWasmInitialized) {
31553 throw new Error("initializeWasm() must be awaited first!");
31555 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
31556 return nativeResponseValue;
31558 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
31560 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
31561 if(!isWasmInitialized) {
31562 throw new Error("initializeWasm() must be awaited first!");
31564 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
31565 // debug statements here
31567 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
31569 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
31570 if(!isWasmInitialized) {
31571 throw new Error("initializeWasm() must be awaited first!");
31573 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
31574 return nativeResponseValue;
31576 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
31578 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
31579 if(!isWasmInitialized) {
31580 throw new Error("initializeWasm() must be awaited first!");
31582 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
31583 // debug statements here
31585 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
31587 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
31588 if(!isWasmInitialized) {
31589 throw new Error("initializeWasm() must be awaited first!");
31591 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
31592 return nativeResponseValue;
31594 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
31596 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
31597 if(!isWasmInitialized) {
31598 throw new Error("initializeWasm() must be awaited first!");
31600 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
31601 return nativeResponseValue;
31603 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
31605 export function CommitmentSigned_clone(orig: bigint): bigint {
31606 if(!isWasmInitialized) {
31607 throw new Error("initializeWasm() must be awaited first!");
31609 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
31610 return nativeResponseValue;
31612 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
31614 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
31615 if(!isWasmInitialized) {
31616 throw new Error("initializeWasm() must be awaited first!");
31618 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
31619 return nativeResponseValue;
31621 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
31623 export function RevokeAndACK_free(this_obj: bigint): void {
31624 if(!isWasmInitialized) {
31625 throw new Error("initializeWasm() must be awaited first!");
31627 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
31628 // debug statements here
31630 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
31632 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
31633 if(!isWasmInitialized) {
31634 throw new Error("initializeWasm() must be awaited first!");
31636 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
31637 return nativeResponseValue;
31639 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31641 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
31642 if(!isWasmInitialized) {
31643 throw new Error("initializeWasm() must be awaited first!");
31645 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
31646 // debug statements here
31648 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
31650 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
31651 if(!isWasmInitialized) {
31652 throw new Error("initializeWasm() must be awaited first!");
31654 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
31655 return nativeResponseValue;
31657 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31659 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
31660 if(!isWasmInitialized) {
31661 throw new Error("initializeWasm() must be awaited first!");
31663 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
31664 // debug statements here
31666 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
31668 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
31669 if(!isWasmInitialized) {
31670 throw new Error("initializeWasm() must be awaited first!");
31672 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
31673 return nativeResponseValue;
31675 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31677 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
31678 if(!isWasmInitialized) {
31679 throw new Error("initializeWasm() must be awaited first!");
31681 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
31682 // debug statements here
31684 // 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);
31686 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
31687 if(!isWasmInitialized) {
31688 throw new Error("initializeWasm() must be awaited first!");
31690 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
31691 return nativeResponseValue;
31693 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
31695 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
31696 if(!isWasmInitialized) {
31697 throw new Error("initializeWasm() must be awaited first!");
31699 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
31700 return nativeResponseValue;
31702 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
31704 export function RevokeAndACK_clone(orig: bigint): bigint {
31705 if(!isWasmInitialized) {
31706 throw new Error("initializeWasm() must be awaited first!");
31708 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
31709 return nativeResponseValue;
31711 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
31713 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
31714 if(!isWasmInitialized) {
31715 throw new Error("initializeWasm() must be awaited first!");
31717 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
31718 return nativeResponseValue;
31720 // void UpdateFee_free(struct LDKUpdateFee this_obj);
31722 export function UpdateFee_free(this_obj: bigint): void {
31723 if(!isWasmInitialized) {
31724 throw new Error("initializeWasm() must be awaited first!");
31726 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
31727 // debug statements here
31729 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
31731 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
31732 if(!isWasmInitialized) {
31733 throw new Error("initializeWasm() must be awaited first!");
31735 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
31736 return nativeResponseValue;
31738 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31740 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
31741 if(!isWasmInitialized) {
31742 throw new Error("initializeWasm() must be awaited first!");
31744 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
31745 // debug statements here
31747 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
31749 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
31750 if(!isWasmInitialized) {
31751 throw new Error("initializeWasm() must be awaited first!");
31753 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
31754 return nativeResponseValue;
31756 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
31758 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
31759 if(!isWasmInitialized) {
31760 throw new Error("initializeWasm() must be awaited first!");
31762 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
31763 // debug statements here
31765 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
31767 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
31768 if(!isWasmInitialized) {
31769 throw new Error("initializeWasm() must be awaited first!");
31771 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
31772 return nativeResponseValue;
31774 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
31776 export function UpdateFee_clone_ptr(arg: bigint): bigint {
31777 if(!isWasmInitialized) {
31778 throw new Error("initializeWasm() must be awaited first!");
31780 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
31781 return nativeResponseValue;
31783 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
31785 export function UpdateFee_clone(orig: bigint): bigint {
31786 if(!isWasmInitialized) {
31787 throw new Error("initializeWasm() must be awaited first!");
31789 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
31790 return nativeResponseValue;
31792 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
31794 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
31795 if(!isWasmInitialized) {
31796 throw new Error("initializeWasm() must be awaited first!");
31798 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
31799 return nativeResponseValue;
31801 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
31803 export function ChannelReestablish_free(this_obj: bigint): void {
31804 if(!isWasmInitialized) {
31805 throw new Error("initializeWasm() must be awaited first!");
31807 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
31808 // debug statements here
31810 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
31812 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
31813 if(!isWasmInitialized) {
31814 throw new Error("initializeWasm() must be awaited first!");
31816 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
31817 return nativeResponseValue;
31819 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31821 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
31822 if(!isWasmInitialized) {
31823 throw new Error("initializeWasm() must be awaited first!");
31825 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
31826 // debug statements here
31828 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
31830 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
31831 if(!isWasmInitialized) {
31832 throw new Error("initializeWasm() must be awaited first!");
31834 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
31835 return nativeResponseValue;
31837 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
31839 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
31840 if(!isWasmInitialized) {
31841 throw new Error("initializeWasm() must be awaited first!");
31843 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
31844 // debug statements here
31846 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
31848 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
31849 if(!isWasmInitialized) {
31850 throw new Error("initializeWasm() must be awaited first!");
31852 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
31853 return nativeResponseValue;
31855 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
31857 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
31858 if(!isWasmInitialized) {
31859 throw new Error("initializeWasm() must be awaited first!");
31861 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
31862 // debug statements here
31864 // const uint8_t (*ChannelReestablish_get_your_last_per_commitment_secret(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
31866 export function ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: bigint): number {
31867 if(!isWasmInitialized) {
31868 throw new Error("initializeWasm() must be awaited first!");
31870 const nativeResponseValue = wasm.TS_ChannelReestablish_get_your_last_per_commitment_secret(this_ptr);
31871 return nativeResponseValue;
31873 // void ChannelReestablish_set_your_last_per_commitment_secret(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31875 export function ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
31876 if(!isWasmInitialized) {
31877 throw new Error("initializeWasm() must be awaited first!");
31879 const nativeResponseValue = wasm.TS_ChannelReestablish_set_your_last_per_commitment_secret(this_ptr, val);
31880 // debug statements here
31882 // struct LDKPublicKey ChannelReestablish_get_my_current_per_commitment_point(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
31884 export function ChannelReestablish_get_my_current_per_commitment_point(this_ptr: bigint): number {
31885 if(!isWasmInitialized) {
31886 throw new Error("initializeWasm() must be awaited first!");
31888 const nativeResponseValue = wasm.TS_ChannelReestablish_get_my_current_per_commitment_point(this_ptr);
31889 return nativeResponseValue;
31891 // void ChannelReestablish_set_my_current_per_commitment_point(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31893 export function ChannelReestablish_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
31894 if(!isWasmInitialized) {
31895 throw new Error("initializeWasm() must be awaited first!");
31897 const nativeResponseValue = wasm.TS_ChannelReestablish_set_my_current_per_commitment_point(this_ptr, val);
31898 // debug statements here
31900 // struct LDKCOption_TxidZ ChannelReestablish_get_next_funding_txid(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
31902 export function ChannelReestablish_get_next_funding_txid(this_ptr: bigint): bigint {
31903 if(!isWasmInitialized) {
31904 throw new Error("initializeWasm() must be awaited first!");
31906 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_funding_txid(this_ptr);
31907 return nativeResponseValue;
31909 // void ChannelReestablish_set_next_funding_txid(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKCOption_TxidZ val);
31911 export function ChannelReestablish_set_next_funding_txid(this_ptr: bigint, val: bigint): void {
31912 if(!isWasmInitialized) {
31913 throw new Error("initializeWasm() must be awaited first!");
31915 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_funding_txid(this_ptr, val);
31916 // debug statements here
31918 // MUST_USE_RES struct LDKChannelReestablish ChannelReestablish_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t next_local_commitment_number_arg, uint64_t next_remote_commitment_number_arg, struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg, struct LDKCOption_TxidZ next_funding_txid_arg);
31920 export function ChannelReestablish_new(channel_id_arg: number, next_local_commitment_number_arg: bigint, next_remote_commitment_number_arg: bigint, your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number, next_funding_txid_arg: bigint): bigint {
31921 if(!isWasmInitialized) {
31922 throw new Error("initializeWasm() must be awaited first!");
31924 const nativeResponseValue = wasm.TS_ChannelReestablish_new(channel_id_arg, next_local_commitment_number_arg, next_remote_commitment_number_arg, your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg, next_funding_txid_arg);
31925 return nativeResponseValue;
31927 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
31929 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
31930 if(!isWasmInitialized) {
31931 throw new Error("initializeWasm() must be awaited first!");
31933 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
31934 return nativeResponseValue;
31936 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
31938 export function ChannelReestablish_clone(orig: bigint): bigint {
31939 if(!isWasmInitialized) {
31940 throw new Error("initializeWasm() must be awaited first!");
31942 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
31943 return nativeResponseValue;
31945 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
31947 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
31948 if(!isWasmInitialized) {
31949 throw new Error("initializeWasm() must be awaited first!");
31951 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
31952 return nativeResponseValue;
31954 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
31956 export function AnnouncementSignatures_free(this_obj: bigint): void {
31957 if(!isWasmInitialized) {
31958 throw new Error("initializeWasm() must be awaited first!");
31960 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
31961 // debug statements here
31963 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
31965 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
31966 if(!isWasmInitialized) {
31967 throw new Error("initializeWasm() must be awaited first!");
31969 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
31970 return nativeResponseValue;
31972 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31974 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
31975 if(!isWasmInitialized) {
31976 throw new Error("initializeWasm() must be awaited first!");
31978 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
31979 // debug statements here
31981 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
31983 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
31984 if(!isWasmInitialized) {
31985 throw new Error("initializeWasm() must be awaited first!");
31987 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
31988 return nativeResponseValue;
31990 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
31992 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
31993 if(!isWasmInitialized) {
31994 throw new Error("initializeWasm() must be awaited first!");
31996 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
31997 // debug statements here
31999 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
32001 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
32002 if(!isWasmInitialized) {
32003 throw new Error("initializeWasm() must be awaited first!");
32005 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
32006 return nativeResponseValue;
32008 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
32010 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
32011 if(!isWasmInitialized) {
32012 throw new Error("initializeWasm() must be awaited first!");
32014 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
32015 // debug statements here
32017 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
32019 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
32020 if(!isWasmInitialized) {
32021 throw new Error("initializeWasm() must be awaited first!");
32023 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
32024 return nativeResponseValue;
32026 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
32028 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
32029 if(!isWasmInitialized) {
32030 throw new Error("initializeWasm() must be awaited first!");
32032 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
32033 // debug statements here
32035 // 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);
32037 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
32038 if(!isWasmInitialized) {
32039 throw new Error("initializeWasm() must be awaited first!");
32041 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
32042 return nativeResponseValue;
32044 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
32046 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
32047 if(!isWasmInitialized) {
32048 throw new Error("initializeWasm() must be awaited first!");
32050 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
32051 return nativeResponseValue;
32053 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
32055 export function AnnouncementSignatures_clone(orig: bigint): bigint {
32056 if(!isWasmInitialized) {
32057 throw new Error("initializeWasm() must be awaited first!");
32059 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
32060 return nativeResponseValue;
32062 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
32064 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
32065 if(!isWasmInitialized) {
32066 throw new Error("initializeWasm() must be awaited first!");
32068 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
32069 return nativeResponseValue;
32071 // void NetAddress_free(struct LDKNetAddress this_ptr);
32073 export function NetAddress_free(this_ptr: bigint): void {
32074 if(!isWasmInitialized) {
32075 throw new Error("initializeWasm() must be awaited first!");
32077 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
32078 // debug statements here
32080 // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
32082 export function NetAddress_clone_ptr(arg: bigint): bigint {
32083 if(!isWasmInitialized) {
32084 throw new Error("initializeWasm() must be awaited first!");
32086 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
32087 return nativeResponseValue;
32089 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
32091 export function NetAddress_clone(orig: bigint): bigint {
32092 if(!isWasmInitialized) {
32093 throw new Error("initializeWasm() must be awaited first!");
32095 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
32096 return nativeResponseValue;
32098 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
32100 export function NetAddress_ipv4(addr: number, port: number): bigint {
32101 if(!isWasmInitialized) {
32102 throw new Error("initializeWasm() must be awaited first!");
32104 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
32105 return nativeResponseValue;
32107 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
32109 export function NetAddress_ipv6(addr: number, port: number): bigint {
32110 if(!isWasmInitialized) {
32111 throw new Error("initializeWasm() must be awaited first!");
32113 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
32114 return nativeResponseValue;
32116 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
32118 export function NetAddress_onion_v2(a: number): bigint {
32119 if(!isWasmInitialized) {
32120 throw new Error("initializeWasm() must be awaited first!");
32122 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
32123 return nativeResponseValue;
32125 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
32127 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
32128 if(!isWasmInitialized) {
32129 throw new Error("initializeWasm() must be awaited first!");
32131 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
32132 return nativeResponseValue;
32134 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
32136 export function NetAddress_hostname(hostname: bigint, port: number): bigint {
32137 if(!isWasmInitialized) {
32138 throw new Error("initializeWasm() must be awaited first!");
32140 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
32141 return nativeResponseValue;
32143 // bool NetAddress_eq(const struct LDKNetAddress *NONNULL_PTR a, const struct LDKNetAddress *NONNULL_PTR b);
32145 export function NetAddress_eq(a: bigint, b: bigint): boolean {
32146 if(!isWasmInitialized) {
32147 throw new Error("initializeWasm() must be awaited first!");
32149 const nativeResponseValue = wasm.TS_NetAddress_eq(a, b);
32150 return nativeResponseValue;
32152 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
32154 export function NetAddress_write(obj: bigint): number {
32155 if(!isWasmInitialized) {
32156 throw new Error("initializeWasm() must be awaited first!");
32158 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
32159 return nativeResponseValue;
32161 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
32163 export function NetAddress_read(ser: number): bigint {
32164 if(!isWasmInitialized) {
32165 throw new Error("initializeWasm() must be awaited first!");
32167 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
32168 return nativeResponseValue;
32170 // void UnsignedGossipMessage_free(struct LDKUnsignedGossipMessage this_ptr);
32172 export function UnsignedGossipMessage_free(this_ptr: bigint): void {
32173 if(!isWasmInitialized) {
32174 throw new Error("initializeWasm() must be awaited first!");
32176 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_free(this_ptr);
32177 // debug statements here
32179 // uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg);
32181 export function UnsignedGossipMessage_clone_ptr(arg: bigint): bigint {
32182 if(!isWasmInitialized) {
32183 throw new Error("initializeWasm() must be awaited first!");
32185 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone_ptr(arg);
32186 return nativeResponseValue;
32188 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_clone(const struct LDKUnsignedGossipMessage *NONNULL_PTR orig);
32190 export function UnsignedGossipMessage_clone(orig: bigint): bigint {
32191 if(!isWasmInitialized) {
32192 throw new Error("initializeWasm() must be awaited first!");
32194 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone(orig);
32195 return nativeResponseValue;
32197 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_announcement(struct LDKUnsignedChannelAnnouncement a);
32199 export function UnsignedGossipMessage_channel_announcement(a: bigint): bigint {
32200 if(!isWasmInitialized) {
32201 throw new Error("initializeWasm() must be awaited first!");
32203 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_announcement(a);
32204 return nativeResponseValue;
32206 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_update(struct LDKUnsignedChannelUpdate a);
32208 export function UnsignedGossipMessage_channel_update(a: bigint): bigint {
32209 if(!isWasmInitialized) {
32210 throw new Error("initializeWasm() must be awaited first!");
32212 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_update(a);
32213 return nativeResponseValue;
32215 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_node_announcement(struct LDKUnsignedNodeAnnouncement a);
32217 export function UnsignedGossipMessage_node_announcement(a: bigint): bigint {
32218 if(!isWasmInitialized) {
32219 throw new Error("initializeWasm() must be awaited first!");
32221 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_node_announcement(a);
32222 return nativeResponseValue;
32224 // struct LDKCVec_u8Z UnsignedGossipMessage_write(const struct LDKUnsignedGossipMessage *NONNULL_PTR obj);
32226 export function UnsignedGossipMessage_write(obj: bigint): number {
32227 if(!isWasmInitialized) {
32228 throw new Error("initializeWasm() must be awaited first!");
32230 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_write(obj);
32231 return nativeResponseValue;
32233 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
32235 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
32236 if(!isWasmInitialized) {
32237 throw new Error("initializeWasm() must be awaited first!");
32239 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
32240 // debug statements here
32242 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
32244 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
32245 if(!isWasmInitialized) {
32246 throw new Error("initializeWasm() must be awaited first!");
32248 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
32249 return nativeResponseValue;
32251 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
32253 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
32254 if(!isWasmInitialized) {
32255 throw new Error("initializeWasm() must be awaited first!");
32257 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
32258 // debug statements here
32260 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
32262 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
32263 if(!isWasmInitialized) {
32264 throw new Error("initializeWasm() must be awaited first!");
32266 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
32267 return nativeResponseValue;
32269 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
32271 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
32272 if(!isWasmInitialized) {
32273 throw new Error("initializeWasm() must be awaited first!");
32275 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
32276 // debug statements here
32278 // struct LDKNodeId UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
32280 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): bigint {
32281 if(!isWasmInitialized) {
32282 throw new Error("initializeWasm() must be awaited first!");
32284 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
32285 return nativeResponseValue;
32287 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
32289 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: bigint): void {
32290 if(!isWasmInitialized) {
32291 throw new Error("initializeWasm() must be awaited first!");
32293 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
32294 // debug statements here
32296 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
32298 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
32299 if(!isWasmInitialized) {
32300 throw new Error("initializeWasm() must be awaited first!");
32302 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
32303 return nativeResponseValue;
32305 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
32307 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
32308 if(!isWasmInitialized) {
32309 throw new Error("initializeWasm() must be awaited first!");
32311 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
32312 // debug statements here
32314 // struct LDKNodeAlias UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
32316 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): bigint {
32317 if(!isWasmInitialized) {
32318 throw new Error("initializeWasm() must be awaited first!");
32320 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
32321 return nativeResponseValue;
32323 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
32325 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: bigint): void {
32326 if(!isWasmInitialized) {
32327 throw new Error("initializeWasm() must be awaited first!");
32329 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
32330 // debug statements here
32332 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
32334 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
32335 if(!isWasmInitialized) {
32336 throw new Error("initializeWasm() must be awaited first!");
32338 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
32339 return nativeResponseValue;
32341 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
32343 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
32344 if(!isWasmInitialized) {
32345 throw new Error("initializeWasm() must be awaited first!");
32347 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
32348 // debug statements here
32350 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
32352 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
32353 if(!isWasmInitialized) {
32354 throw new Error("initializeWasm() must be awaited first!");
32356 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
32357 return nativeResponseValue;
32359 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
32361 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
32362 if(!isWasmInitialized) {
32363 throw new Error("initializeWasm() must be awaited first!");
32365 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
32366 return nativeResponseValue;
32368 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
32370 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
32371 if(!isWasmInitialized) {
32372 throw new Error("initializeWasm() must be awaited first!");
32374 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
32375 return nativeResponseValue;
32377 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
32379 export function NodeAnnouncement_free(this_obj: bigint): void {
32380 if(!isWasmInitialized) {
32381 throw new Error("initializeWasm() must be awaited first!");
32383 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
32384 // debug statements here
32386 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
32388 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
32389 if(!isWasmInitialized) {
32390 throw new Error("initializeWasm() must be awaited first!");
32392 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
32393 return nativeResponseValue;
32395 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
32397 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
32398 if(!isWasmInitialized) {
32399 throw new Error("initializeWasm() must be awaited first!");
32401 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
32402 // debug statements here
32404 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
32406 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
32407 if(!isWasmInitialized) {
32408 throw new Error("initializeWasm() must be awaited first!");
32410 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
32411 return nativeResponseValue;
32413 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
32415 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
32416 if(!isWasmInitialized) {
32417 throw new Error("initializeWasm() must be awaited first!");
32419 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
32420 // debug statements here
32422 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
32424 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
32425 if(!isWasmInitialized) {
32426 throw new Error("initializeWasm() must be awaited first!");
32428 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
32429 return nativeResponseValue;
32431 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
32433 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
32434 if(!isWasmInitialized) {
32435 throw new Error("initializeWasm() must be awaited first!");
32437 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
32438 return nativeResponseValue;
32440 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
32442 export function NodeAnnouncement_clone(orig: bigint): bigint {
32443 if(!isWasmInitialized) {
32444 throw new Error("initializeWasm() must be awaited first!");
32446 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
32447 return nativeResponseValue;
32449 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
32451 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
32452 if(!isWasmInitialized) {
32453 throw new Error("initializeWasm() must be awaited first!");
32455 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
32456 return nativeResponseValue;
32458 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
32460 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
32461 if(!isWasmInitialized) {
32462 throw new Error("initializeWasm() must be awaited first!");
32464 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
32465 // debug statements here
32467 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
32469 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
32470 if(!isWasmInitialized) {
32471 throw new Error("initializeWasm() must be awaited first!");
32473 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
32474 return nativeResponseValue;
32476 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
32478 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
32479 if(!isWasmInitialized) {
32480 throw new Error("initializeWasm() must be awaited first!");
32482 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
32483 // debug statements here
32485 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
32487 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
32488 if(!isWasmInitialized) {
32489 throw new Error("initializeWasm() must be awaited first!");
32491 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
32492 return nativeResponseValue;
32494 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32496 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
32497 if(!isWasmInitialized) {
32498 throw new Error("initializeWasm() must be awaited first!");
32500 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
32501 // debug statements here
32503 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
32505 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
32506 if(!isWasmInitialized) {
32507 throw new Error("initializeWasm() must be awaited first!");
32509 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
32510 return nativeResponseValue;
32512 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
32514 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
32515 if(!isWasmInitialized) {
32516 throw new Error("initializeWasm() must be awaited first!");
32518 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
32519 // debug statements here
32521 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
32523 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): bigint {
32524 if(!isWasmInitialized) {
32525 throw new Error("initializeWasm() must be awaited first!");
32527 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
32528 return nativeResponseValue;
32530 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
32532 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: bigint): void {
32533 if(!isWasmInitialized) {
32534 throw new Error("initializeWasm() must be awaited first!");
32536 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
32537 // debug statements here
32539 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
32541 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): bigint {
32542 if(!isWasmInitialized) {
32543 throw new Error("initializeWasm() must be awaited first!");
32545 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
32546 return nativeResponseValue;
32548 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
32550 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: bigint): void {
32551 if(!isWasmInitialized) {
32552 throw new Error("initializeWasm() must be awaited first!");
32554 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
32555 // debug statements here
32557 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
32559 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): bigint {
32560 if(!isWasmInitialized) {
32561 throw new Error("initializeWasm() must be awaited first!");
32563 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
32564 return nativeResponseValue;
32566 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
32568 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: bigint): void {
32569 if(!isWasmInitialized) {
32570 throw new Error("initializeWasm() must be awaited first!");
32572 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
32573 // debug statements here
32575 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
32577 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): bigint {
32578 if(!isWasmInitialized) {
32579 throw new Error("initializeWasm() must be awaited first!");
32581 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
32582 return nativeResponseValue;
32584 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
32586 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: bigint): void {
32587 if(!isWasmInitialized) {
32588 throw new Error("initializeWasm() must be awaited first!");
32590 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
32591 // debug statements here
32593 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
32595 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
32596 if(!isWasmInitialized) {
32597 throw new Error("initializeWasm() must be awaited first!");
32599 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
32600 return nativeResponseValue;
32602 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
32604 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
32605 if(!isWasmInitialized) {
32606 throw new Error("initializeWasm() must be awaited first!");
32608 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
32609 return nativeResponseValue;
32611 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
32613 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
32614 if(!isWasmInitialized) {
32615 throw new Error("initializeWasm() must be awaited first!");
32617 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
32618 return nativeResponseValue;
32620 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
32622 export function ChannelAnnouncement_free(this_obj: bigint): void {
32623 if(!isWasmInitialized) {
32624 throw new Error("initializeWasm() must be awaited first!");
32626 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
32627 // debug statements here
32629 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
32631 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
32632 if(!isWasmInitialized) {
32633 throw new Error("initializeWasm() must be awaited first!");
32635 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
32636 return nativeResponseValue;
32638 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
32640 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
32641 if(!isWasmInitialized) {
32642 throw new Error("initializeWasm() must be awaited first!");
32644 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
32645 // debug statements here
32647 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
32649 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
32650 if(!isWasmInitialized) {
32651 throw new Error("initializeWasm() must be awaited first!");
32653 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
32654 return nativeResponseValue;
32656 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
32658 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
32659 if(!isWasmInitialized) {
32660 throw new Error("initializeWasm() must be awaited first!");
32662 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
32663 // debug statements here
32665 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
32667 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
32668 if(!isWasmInitialized) {
32669 throw new Error("initializeWasm() must be awaited first!");
32671 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
32672 return nativeResponseValue;
32674 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
32676 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
32677 if(!isWasmInitialized) {
32678 throw new Error("initializeWasm() must be awaited first!");
32680 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
32681 // debug statements here
32683 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
32685 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
32686 if(!isWasmInitialized) {
32687 throw new Error("initializeWasm() must be awaited first!");
32689 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
32690 return nativeResponseValue;
32692 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
32694 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
32695 if(!isWasmInitialized) {
32696 throw new Error("initializeWasm() must be awaited first!");
32698 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
32699 // debug statements here
32701 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
32703 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
32704 if(!isWasmInitialized) {
32705 throw new Error("initializeWasm() must be awaited first!");
32707 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
32708 return nativeResponseValue;
32710 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
32712 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
32713 if(!isWasmInitialized) {
32714 throw new Error("initializeWasm() must be awaited first!");
32716 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
32717 // debug statements here
32719 // 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);
32721 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 {
32722 if(!isWasmInitialized) {
32723 throw new Error("initializeWasm() must be awaited first!");
32725 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
32726 return nativeResponseValue;
32728 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
32730 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
32731 if(!isWasmInitialized) {
32732 throw new Error("initializeWasm() must be awaited first!");
32734 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
32735 return nativeResponseValue;
32737 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
32739 export function ChannelAnnouncement_clone(orig: bigint): bigint {
32740 if(!isWasmInitialized) {
32741 throw new Error("initializeWasm() must be awaited first!");
32743 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
32744 return nativeResponseValue;
32746 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
32748 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
32749 if(!isWasmInitialized) {
32750 throw new Error("initializeWasm() must be awaited first!");
32752 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
32753 return nativeResponseValue;
32755 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
32757 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
32758 if(!isWasmInitialized) {
32759 throw new Error("initializeWasm() must be awaited first!");
32761 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
32762 // debug statements here
32764 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
32766 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
32767 if(!isWasmInitialized) {
32768 throw new Error("initializeWasm() must be awaited first!");
32770 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
32771 return nativeResponseValue;
32773 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32775 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
32776 if(!isWasmInitialized) {
32777 throw new Error("initializeWasm() must be awaited first!");
32779 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
32780 // debug statements here
32782 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32784 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
32785 if(!isWasmInitialized) {
32786 throw new Error("initializeWasm() must be awaited first!");
32788 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
32789 return nativeResponseValue;
32791 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
32793 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
32794 if(!isWasmInitialized) {
32795 throw new Error("initializeWasm() must be awaited first!");
32797 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
32798 // debug statements here
32800 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32802 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
32803 if(!isWasmInitialized) {
32804 throw new Error("initializeWasm() must be awaited first!");
32806 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
32807 return nativeResponseValue;
32809 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
32811 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
32812 if(!isWasmInitialized) {
32813 throw new Error("initializeWasm() must be awaited first!");
32815 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
32816 // debug statements here
32818 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32820 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
32821 if(!isWasmInitialized) {
32822 throw new Error("initializeWasm() must be awaited first!");
32824 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
32825 return nativeResponseValue;
32827 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
32829 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
32830 if(!isWasmInitialized) {
32831 throw new Error("initializeWasm() must be awaited first!");
32833 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
32834 // debug statements here
32836 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32838 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
32839 if(!isWasmInitialized) {
32840 throw new Error("initializeWasm() must be awaited first!");
32842 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
32843 return nativeResponseValue;
32845 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
32847 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
32848 if(!isWasmInitialized) {
32849 throw new Error("initializeWasm() must be awaited first!");
32851 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
32852 // debug statements here
32854 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32856 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
32857 if(!isWasmInitialized) {
32858 throw new Error("initializeWasm() must be awaited first!");
32860 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
32861 return nativeResponseValue;
32863 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
32865 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
32866 if(!isWasmInitialized) {
32867 throw new Error("initializeWasm() must be awaited first!");
32869 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
32870 // debug statements here
32872 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32874 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
32875 if(!isWasmInitialized) {
32876 throw new Error("initializeWasm() must be awaited first!");
32878 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
32879 return nativeResponseValue;
32881 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
32883 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
32884 if(!isWasmInitialized) {
32885 throw new Error("initializeWasm() must be awaited first!");
32887 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
32888 // debug statements here
32890 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32892 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
32893 if(!isWasmInitialized) {
32894 throw new Error("initializeWasm() must be awaited first!");
32896 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
32897 return nativeResponseValue;
32899 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
32901 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
32902 if(!isWasmInitialized) {
32903 throw new Error("initializeWasm() must be awaited first!");
32905 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
32906 // debug statements here
32908 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32910 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
32911 if(!isWasmInitialized) {
32912 throw new Error("initializeWasm() must be awaited first!");
32914 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
32915 return nativeResponseValue;
32917 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
32919 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
32920 if(!isWasmInitialized) {
32921 throw new Error("initializeWasm() must be awaited first!");
32923 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
32924 // debug statements here
32926 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
32928 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
32929 if(!isWasmInitialized) {
32930 throw new Error("initializeWasm() must be awaited first!");
32932 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
32933 return nativeResponseValue;
32935 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32937 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
32938 if(!isWasmInitialized) {
32939 throw new Error("initializeWasm() must be awaited first!");
32941 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
32942 // debug statements here
32944 // 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);
32946 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 {
32947 if(!isWasmInitialized) {
32948 throw new Error("initializeWasm() must be awaited first!");
32950 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);
32951 return nativeResponseValue;
32953 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
32955 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
32956 if(!isWasmInitialized) {
32957 throw new Error("initializeWasm() must be awaited first!");
32959 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
32960 return nativeResponseValue;
32962 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
32964 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
32965 if(!isWasmInitialized) {
32966 throw new Error("initializeWasm() must be awaited first!");
32968 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
32969 return nativeResponseValue;
32971 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
32973 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
32974 if(!isWasmInitialized) {
32975 throw new Error("initializeWasm() must be awaited first!");
32977 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
32978 return nativeResponseValue;
32980 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
32982 export function ChannelUpdate_free(this_obj: bigint): void {
32983 if(!isWasmInitialized) {
32984 throw new Error("initializeWasm() must be awaited first!");
32986 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
32987 // debug statements here
32989 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
32991 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
32992 if(!isWasmInitialized) {
32993 throw new Error("initializeWasm() must be awaited first!");
32995 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
32996 return nativeResponseValue;
32998 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
33000 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
33001 if(!isWasmInitialized) {
33002 throw new Error("initializeWasm() must be awaited first!");
33004 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
33005 // debug statements here
33007 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
33009 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
33010 if(!isWasmInitialized) {
33011 throw new Error("initializeWasm() must be awaited first!");
33013 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
33014 return nativeResponseValue;
33016 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
33018 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
33019 if(!isWasmInitialized) {
33020 throw new Error("initializeWasm() must be awaited first!");
33022 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
33023 // debug statements here
33025 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
33027 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
33028 if(!isWasmInitialized) {
33029 throw new Error("initializeWasm() must be awaited first!");
33031 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
33032 return nativeResponseValue;
33034 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
33036 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
33037 if(!isWasmInitialized) {
33038 throw new Error("initializeWasm() must be awaited first!");
33040 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
33041 return nativeResponseValue;
33043 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
33045 export function ChannelUpdate_clone(orig: bigint): bigint {
33046 if(!isWasmInitialized) {
33047 throw new Error("initializeWasm() must be awaited first!");
33049 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
33050 return nativeResponseValue;
33052 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
33054 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
33055 if(!isWasmInitialized) {
33056 throw new Error("initializeWasm() must be awaited first!");
33058 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
33059 return nativeResponseValue;
33061 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
33063 export function QueryChannelRange_free(this_obj: bigint): void {
33064 if(!isWasmInitialized) {
33065 throw new Error("initializeWasm() must be awaited first!");
33067 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
33068 // debug statements here
33070 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
33072 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
33073 if(!isWasmInitialized) {
33074 throw new Error("initializeWasm() must be awaited first!");
33076 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
33077 return nativeResponseValue;
33079 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33081 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
33082 if(!isWasmInitialized) {
33083 throw new Error("initializeWasm() must be awaited first!");
33085 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
33086 // debug statements here
33088 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
33090 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
33091 if(!isWasmInitialized) {
33092 throw new Error("initializeWasm() must be awaited first!");
33094 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
33095 return nativeResponseValue;
33097 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
33099 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
33100 if(!isWasmInitialized) {
33101 throw new Error("initializeWasm() must be awaited first!");
33103 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
33104 // debug statements here
33106 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
33108 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
33109 if(!isWasmInitialized) {
33110 throw new Error("initializeWasm() must be awaited first!");
33112 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
33113 return nativeResponseValue;
33115 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
33117 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
33118 if(!isWasmInitialized) {
33119 throw new Error("initializeWasm() must be awaited first!");
33121 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
33122 // debug statements here
33124 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
33126 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
33127 if(!isWasmInitialized) {
33128 throw new Error("initializeWasm() must be awaited first!");
33130 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
33131 return nativeResponseValue;
33133 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
33135 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
33136 if(!isWasmInitialized) {
33137 throw new Error("initializeWasm() must be awaited first!");
33139 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
33140 return nativeResponseValue;
33142 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
33144 export function QueryChannelRange_clone(orig: bigint): bigint {
33145 if(!isWasmInitialized) {
33146 throw new Error("initializeWasm() must be awaited first!");
33148 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
33149 return nativeResponseValue;
33151 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
33153 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
33154 if(!isWasmInitialized) {
33155 throw new Error("initializeWasm() must be awaited first!");
33157 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
33158 return nativeResponseValue;
33160 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
33162 export function ReplyChannelRange_free(this_obj: bigint): void {
33163 if(!isWasmInitialized) {
33164 throw new Error("initializeWasm() must be awaited first!");
33166 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
33167 // debug statements here
33169 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
33171 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
33172 if(!isWasmInitialized) {
33173 throw new Error("initializeWasm() must be awaited first!");
33175 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
33176 return nativeResponseValue;
33178 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33180 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
33181 if(!isWasmInitialized) {
33182 throw new Error("initializeWasm() must be awaited first!");
33184 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
33185 // debug statements here
33187 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
33189 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
33190 if(!isWasmInitialized) {
33191 throw new Error("initializeWasm() must be awaited first!");
33193 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
33194 return nativeResponseValue;
33196 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
33198 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
33199 if(!isWasmInitialized) {
33200 throw new Error("initializeWasm() must be awaited first!");
33202 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
33203 // debug statements here
33205 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
33207 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
33208 if(!isWasmInitialized) {
33209 throw new Error("initializeWasm() must be awaited first!");
33211 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
33212 return nativeResponseValue;
33214 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
33216 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
33217 if(!isWasmInitialized) {
33218 throw new Error("initializeWasm() must be awaited first!");
33220 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
33221 // debug statements here
33223 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
33225 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
33226 if(!isWasmInitialized) {
33227 throw new Error("initializeWasm() must be awaited first!");
33229 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
33230 return nativeResponseValue;
33232 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
33234 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
33235 if(!isWasmInitialized) {
33236 throw new Error("initializeWasm() must be awaited first!");
33238 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
33239 // debug statements here
33241 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
33243 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
33244 if(!isWasmInitialized) {
33245 throw new Error("initializeWasm() must be awaited first!");
33247 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
33248 return nativeResponseValue;
33250 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
33252 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
33253 if(!isWasmInitialized) {
33254 throw new Error("initializeWasm() must be awaited first!");
33256 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
33257 // debug statements here
33259 // 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);
33261 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 {
33262 if(!isWasmInitialized) {
33263 throw new Error("initializeWasm() must be awaited first!");
33265 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
33266 return nativeResponseValue;
33268 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
33270 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
33271 if(!isWasmInitialized) {
33272 throw new Error("initializeWasm() must be awaited first!");
33274 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
33275 return nativeResponseValue;
33277 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
33279 export function ReplyChannelRange_clone(orig: bigint): bigint {
33280 if(!isWasmInitialized) {
33281 throw new Error("initializeWasm() must be awaited first!");
33283 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
33284 return nativeResponseValue;
33286 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
33288 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
33289 if(!isWasmInitialized) {
33290 throw new Error("initializeWasm() must be awaited first!");
33292 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
33293 return nativeResponseValue;
33295 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
33297 export function QueryShortChannelIds_free(this_obj: bigint): void {
33298 if(!isWasmInitialized) {
33299 throw new Error("initializeWasm() must be awaited first!");
33301 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
33302 // debug statements here
33304 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
33306 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
33307 if(!isWasmInitialized) {
33308 throw new Error("initializeWasm() must be awaited first!");
33310 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
33311 return nativeResponseValue;
33313 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33315 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
33316 if(!isWasmInitialized) {
33317 throw new Error("initializeWasm() must be awaited first!");
33319 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
33320 // debug statements here
33322 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
33324 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
33325 if(!isWasmInitialized) {
33326 throw new Error("initializeWasm() must be awaited first!");
33328 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
33329 return nativeResponseValue;
33331 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
33333 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
33334 if(!isWasmInitialized) {
33335 throw new Error("initializeWasm() must be awaited first!");
33337 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
33338 // debug statements here
33340 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
33342 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
33343 if(!isWasmInitialized) {
33344 throw new Error("initializeWasm() must be awaited first!");
33346 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
33347 return nativeResponseValue;
33349 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
33351 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
33352 if(!isWasmInitialized) {
33353 throw new Error("initializeWasm() must be awaited first!");
33355 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
33356 return nativeResponseValue;
33358 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
33360 export function QueryShortChannelIds_clone(orig: bigint): bigint {
33361 if(!isWasmInitialized) {
33362 throw new Error("initializeWasm() must be awaited first!");
33364 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
33365 return nativeResponseValue;
33367 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
33369 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
33370 if(!isWasmInitialized) {
33371 throw new Error("initializeWasm() must be awaited first!");
33373 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
33374 return nativeResponseValue;
33376 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
33378 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
33379 if(!isWasmInitialized) {
33380 throw new Error("initializeWasm() must be awaited first!");
33382 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
33383 // debug statements here
33385 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
33387 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
33388 if(!isWasmInitialized) {
33389 throw new Error("initializeWasm() must be awaited first!");
33391 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
33392 return nativeResponseValue;
33394 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33396 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
33397 if(!isWasmInitialized) {
33398 throw new Error("initializeWasm() must be awaited first!");
33400 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
33401 // debug statements here
33403 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
33405 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
33406 if(!isWasmInitialized) {
33407 throw new Error("initializeWasm() must be awaited first!");
33409 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
33410 return nativeResponseValue;
33412 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
33414 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
33415 if(!isWasmInitialized) {
33416 throw new Error("initializeWasm() must be awaited first!");
33418 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
33419 // debug statements here
33421 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
33423 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
33424 if(!isWasmInitialized) {
33425 throw new Error("initializeWasm() must be awaited first!");
33427 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
33428 return nativeResponseValue;
33430 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
33432 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
33433 if(!isWasmInitialized) {
33434 throw new Error("initializeWasm() must be awaited first!");
33436 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
33437 return nativeResponseValue;
33439 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
33441 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
33442 if(!isWasmInitialized) {
33443 throw new Error("initializeWasm() must be awaited first!");
33445 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
33446 return nativeResponseValue;
33448 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
33450 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
33451 if(!isWasmInitialized) {
33452 throw new Error("initializeWasm() must be awaited first!");
33454 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
33455 return nativeResponseValue;
33457 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
33459 export function GossipTimestampFilter_free(this_obj: bigint): void {
33460 if(!isWasmInitialized) {
33461 throw new Error("initializeWasm() must be awaited first!");
33463 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
33464 // debug statements here
33466 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
33468 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
33469 if(!isWasmInitialized) {
33470 throw new Error("initializeWasm() must be awaited first!");
33472 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
33473 return nativeResponseValue;
33475 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33477 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
33478 if(!isWasmInitialized) {
33479 throw new Error("initializeWasm() must be awaited first!");
33481 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
33482 // debug statements here
33484 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
33486 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
33487 if(!isWasmInitialized) {
33488 throw new Error("initializeWasm() must be awaited first!");
33490 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
33491 return nativeResponseValue;
33493 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
33495 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
33496 if(!isWasmInitialized) {
33497 throw new Error("initializeWasm() must be awaited first!");
33499 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
33500 // debug statements here
33502 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
33504 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
33505 if(!isWasmInitialized) {
33506 throw new Error("initializeWasm() must be awaited first!");
33508 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
33509 return nativeResponseValue;
33511 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
33513 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
33514 if(!isWasmInitialized) {
33515 throw new Error("initializeWasm() must be awaited first!");
33517 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
33518 // debug statements here
33520 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
33522 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
33523 if(!isWasmInitialized) {
33524 throw new Error("initializeWasm() must be awaited first!");
33526 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
33527 return nativeResponseValue;
33529 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
33531 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
33532 if(!isWasmInitialized) {
33533 throw new Error("initializeWasm() must be awaited first!");
33535 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
33536 return nativeResponseValue;
33538 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
33540 export function GossipTimestampFilter_clone(orig: bigint): bigint {
33541 if(!isWasmInitialized) {
33542 throw new Error("initializeWasm() must be awaited first!");
33544 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
33545 return nativeResponseValue;
33547 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
33549 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
33550 if(!isWasmInitialized) {
33551 throw new Error("initializeWasm() must be awaited first!");
33553 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
33554 return nativeResponseValue;
33556 // void ErrorAction_free(struct LDKErrorAction this_ptr);
33558 export function ErrorAction_free(this_ptr: bigint): void {
33559 if(!isWasmInitialized) {
33560 throw new Error("initializeWasm() must be awaited first!");
33562 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
33563 // debug statements here
33565 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
33567 export function ErrorAction_clone_ptr(arg: bigint): bigint {
33568 if(!isWasmInitialized) {
33569 throw new Error("initializeWasm() must be awaited first!");
33571 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
33572 return nativeResponseValue;
33574 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
33576 export function ErrorAction_clone(orig: bigint): bigint {
33577 if(!isWasmInitialized) {
33578 throw new Error("initializeWasm() must be awaited first!");
33580 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
33581 return nativeResponseValue;
33583 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
33585 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
33586 if(!isWasmInitialized) {
33587 throw new Error("initializeWasm() must be awaited first!");
33589 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
33590 return nativeResponseValue;
33592 // struct LDKErrorAction ErrorAction_disconnect_peer_with_warning(struct LDKWarningMessage msg);
33594 export function ErrorAction_disconnect_peer_with_warning(msg: bigint): bigint {
33595 if(!isWasmInitialized) {
33596 throw new Error("initializeWasm() must be awaited first!");
33598 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer_with_warning(msg);
33599 return nativeResponseValue;
33601 // struct LDKErrorAction ErrorAction_ignore_error(void);
33603 export function ErrorAction_ignore_error(): bigint {
33604 if(!isWasmInitialized) {
33605 throw new Error("initializeWasm() must be awaited first!");
33607 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
33608 return nativeResponseValue;
33610 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
33612 export function ErrorAction_ignore_and_log(a: Level): bigint {
33613 if(!isWasmInitialized) {
33614 throw new Error("initializeWasm() must be awaited first!");
33616 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
33617 return nativeResponseValue;
33619 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
33621 export function ErrorAction_ignore_duplicate_gossip(): bigint {
33622 if(!isWasmInitialized) {
33623 throw new Error("initializeWasm() must be awaited first!");
33625 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
33626 return nativeResponseValue;
33628 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
33630 export function ErrorAction_send_error_message(msg: bigint): bigint {
33631 if(!isWasmInitialized) {
33632 throw new Error("initializeWasm() must be awaited first!");
33634 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
33635 return nativeResponseValue;
33637 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
33639 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
33640 if(!isWasmInitialized) {
33641 throw new Error("initializeWasm() must be awaited first!");
33643 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
33644 return nativeResponseValue;
33646 // void LightningError_free(struct LDKLightningError this_obj);
33648 export function LightningError_free(this_obj: bigint): void {
33649 if(!isWasmInitialized) {
33650 throw new Error("initializeWasm() must be awaited first!");
33652 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
33653 // debug statements here
33655 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
33657 export function LightningError_get_err(this_ptr: bigint): number {
33658 if(!isWasmInitialized) {
33659 throw new Error("initializeWasm() must be awaited first!");
33661 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
33662 return nativeResponseValue;
33664 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
33666 export function LightningError_set_err(this_ptr: bigint, val: number): void {
33667 if(!isWasmInitialized) {
33668 throw new Error("initializeWasm() must be awaited first!");
33670 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
33671 // debug statements here
33673 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
33675 export function LightningError_get_action(this_ptr: bigint): bigint {
33676 if(!isWasmInitialized) {
33677 throw new Error("initializeWasm() must be awaited first!");
33679 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
33680 return nativeResponseValue;
33682 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
33684 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
33685 if(!isWasmInitialized) {
33686 throw new Error("initializeWasm() must be awaited first!");
33688 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
33689 // debug statements here
33691 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
33693 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
33694 if(!isWasmInitialized) {
33695 throw new Error("initializeWasm() must be awaited first!");
33697 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
33698 return nativeResponseValue;
33700 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
33702 export function LightningError_clone_ptr(arg: bigint): bigint {
33703 if(!isWasmInitialized) {
33704 throw new Error("initializeWasm() must be awaited first!");
33706 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
33707 return nativeResponseValue;
33709 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
33711 export function LightningError_clone(orig: bigint): bigint {
33712 if(!isWasmInitialized) {
33713 throw new Error("initializeWasm() must be awaited first!");
33715 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
33716 return nativeResponseValue;
33718 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
33720 export function CommitmentUpdate_free(this_obj: bigint): void {
33721 if(!isWasmInitialized) {
33722 throw new Error("initializeWasm() must be awaited first!");
33724 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
33725 // debug statements here
33727 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
33729 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
33730 if(!isWasmInitialized) {
33731 throw new Error("initializeWasm() must be awaited first!");
33733 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
33734 return nativeResponseValue;
33736 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
33738 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
33739 if(!isWasmInitialized) {
33740 throw new Error("initializeWasm() must be awaited first!");
33742 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
33743 // debug statements here
33745 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
33747 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
33748 if(!isWasmInitialized) {
33749 throw new Error("initializeWasm() must be awaited first!");
33751 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
33752 return nativeResponseValue;
33754 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
33756 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
33757 if(!isWasmInitialized) {
33758 throw new Error("initializeWasm() must be awaited first!");
33760 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
33761 // debug statements here
33763 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
33765 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
33766 if(!isWasmInitialized) {
33767 throw new Error("initializeWasm() must be awaited first!");
33769 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
33770 return nativeResponseValue;
33772 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
33774 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
33775 if(!isWasmInitialized) {
33776 throw new Error("initializeWasm() must be awaited first!");
33778 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
33779 // debug statements here
33781 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
33783 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
33784 if(!isWasmInitialized) {
33785 throw new Error("initializeWasm() must be awaited first!");
33787 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
33788 return nativeResponseValue;
33790 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
33792 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
33793 if(!isWasmInitialized) {
33794 throw new Error("initializeWasm() must be awaited first!");
33796 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
33797 // debug statements here
33799 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
33801 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
33802 if(!isWasmInitialized) {
33803 throw new Error("initializeWasm() must be awaited first!");
33805 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
33806 return nativeResponseValue;
33808 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
33810 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
33811 if(!isWasmInitialized) {
33812 throw new Error("initializeWasm() must be awaited first!");
33814 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
33815 // debug statements here
33817 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
33819 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
33820 if(!isWasmInitialized) {
33821 throw new Error("initializeWasm() must be awaited first!");
33823 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
33824 return nativeResponseValue;
33826 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
33828 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
33829 if(!isWasmInitialized) {
33830 throw new Error("initializeWasm() must be awaited first!");
33832 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
33833 // debug statements here
33835 // 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);
33837 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 {
33838 if(!isWasmInitialized) {
33839 throw new Error("initializeWasm() must be awaited first!");
33841 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);
33842 return nativeResponseValue;
33844 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
33846 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
33847 if(!isWasmInitialized) {
33848 throw new Error("initializeWasm() must be awaited first!");
33850 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
33851 return nativeResponseValue;
33853 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
33855 export function CommitmentUpdate_clone(orig: bigint): bigint {
33856 if(!isWasmInitialized) {
33857 throw new Error("initializeWasm() must be awaited first!");
33859 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
33860 return nativeResponseValue;
33862 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
33864 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
33865 if(!isWasmInitialized) {
33866 throw new Error("initializeWasm() must be awaited first!");
33868 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
33869 return nativeResponseValue;
33871 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
33873 export function ChannelMessageHandler_free(this_ptr: bigint): void {
33874 if(!isWasmInitialized) {
33875 throw new Error("initializeWasm() must be awaited first!");
33877 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
33878 // debug statements here
33880 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
33882 export function RoutingMessageHandler_free(this_ptr: bigint): void {
33883 if(!isWasmInitialized) {
33884 throw new Error("initializeWasm() must be awaited first!");
33886 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
33887 // debug statements here
33889 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
33891 export function OnionMessageHandler_free(this_ptr: bigint): void {
33892 if(!isWasmInitialized) {
33893 throw new Error("initializeWasm() must be awaited first!");
33895 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
33896 // debug statements here
33898 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
33900 export function AcceptChannel_write(obj: bigint): number {
33901 if(!isWasmInitialized) {
33902 throw new Error("initializeWasm() must be awaited first!");
33904 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
33905 return nativeResponseValue;
33907 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
33909 export function AcceptChannel_read(ser: number): bigint {
33910 if(!isWasmInitialized) {
33911 throw new Error("initializeWasm() must be awaited first!");
33913 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
33914 return nativeResponseValue;
33916 // struct LDKCVec_u8Z AcceptChannelV2_write(const struct LDKAcceptChannelV2 *NONNULL_PTR obj);
33918 export function AcceptChannelV2_write(obj: bigint): number {
33919 if(!isWasmInitialized) {
33920 throw new Error("initializeWasm() must be awaited first!");
33922 const nativeResponseValue = wasm.TS_AcceptChannelV2_write(obj);
33923 return nativeResponseValue;
33925 // struct LDKCResult_AcceptChannelV2DecodeErrorZ AcceptChannelV2_read(struct LDKu8slice ser);
33927 export function AcceptChannelV2_read(ser: number): bigint {
33928 if(!isWasmInitialized) {
33929 throw new Error("initializeWasm() must be awaited first!");
33931 const nativeResponseValue = wasm.TS_AcceptChannelV2_read(ser);
33932 return nativeResponseValue;
33934 // struct LDKCVec_u8Z TxAddInput_write(const struct LDKTxAddInput *NONNULL_PTR obj);
33936 export function TxAddInput_write(obj: bigint): number {
33937 if(!isWasmInitialized) {
33938 throw new Error("initializeWasm() must be awaited first!");
33940 const nativeResponseValue = wasm.TS_TxAddInput_write(obj);
33941 return nativeResponseValue;
33943 // struct LDKCResult_TxAddInputDecodeErrorZ TxAddInput_read(struct LDKu8slice ser);
33945 export function TxAddInput_read(ser: number): bigint {
33946 if(!isWasmInitialized) {
33947 throw new Error("initializeWasm() must be awaited first!");
33949 const nativeResponseValue = wasm.TS_TxAddInput_read(ser);
33950 return nativeResponseValue;
33952 // struct LDKCVec_u8Z TxAddOutput_write(const struct LDKTxAddOutput *NONNULL_PTR obj);
33954 export function TxAddOutput_write(obj: bigint): number {
33955 if(!isWasmInitialized) {
33956 throw new Error("initializeWasm() must be awaited first!");
33958 const nativeResponseValue = wasm.TS_TxAddOutput_write(obj);
33959 return nativeResponseValue;
33961 // struct LDKCResult_TxAddOutputDecodeErrorZ TxAddOutput_read(struct LDKu8slice ser);
33963 export function TxAddOutput_read(ser: number): bigint {
33964 if(!isWasmInitialized) {
33965 throw new Error("initializeWasm() must be awaited first!");
33967 const nativeResponseValue = wasm.TS_TxAddOutput_read(ser);
33968 return nativeResponseValue;
33970 // struct LDKCVec_u8Z TxRemoveInput_write(const struct LDKTxRemoveInput *NONNULL_PTR obj);
33972 export function TxRemoveInput_write(obj: bigint): number {
33973 if(!isWasmInitialized) {
33974 throw new Error("initializeWasm() must be awaited first!");
33976 const nativeResponseValue = wasm.TS_TxRemoveInput_write(obj);
33977 return nativeResponseValue;
33979 // struct LDKCResult_TxRemoveInputDecodeErrorZ TxRemoveInput_read(struct LDKu8slice ser);
33981 export function TxRemoveInput_read(ser: number): bigint {
33982 if(!isWasmInitialized) {
33983 throw new Error("initializeWasm() must be awaited first!");
33985 const nativeResponseValue = wasm.TS_TxRemoveInput_read(ser);
33986 return nativeResponseValue;
33988 // struct LDKCVec_u8Z TxRemoveOutput_write(const struct LDKTxRemoveOutput *NONNULL_PTR obj);
33990 export function TxRemoveOutput_write(obj: bigint): number {
33991 if(!isWasmInitialized) {
33992 throw new Error("initializeWasm() must be awaited first!");
33994 const nativeResponseValue = wasm.TS_TxRemoveOutput_write(obj);
33995 return nativeResponseValue;
33997 // struct LDKCResult_TxRemoveOutputDecodeErrorZ TxRemoveOutput_read(struct LDKu8slice ser);
33999 export function TxRemoveOutput_read(ser: number): bigint {
34000 if(!isWasmInitialized) {
34001 throw new Error("initializeWasm() must be awaited first!");
34003 const nativeResponseValue = wasm.TS_TxRemoveOutput_read(ser);
34004 return nativeResponseValue;
34006 // struct LDKCVec_u8Z TxComplete_write(const struct LDKTxComplete *NONNULL_PTR obj);
34008 export function TxComplete_write(obj: bigint): number {
34009 if(!isWasmInitialized) {
34010 throw new Error("initializeWasm() must be awaited first!");
34012 const nativeResponseValue = wasm.TS_TxComplete_write(obj);
34013 return nativeResponseValue;
34015 // struct LDKCResult_TxCompleteDecodeErrorZ TxComplete_read(struct LDKu8slice ser);
34017 export function TxComplete_read(ser: number): bigint {
34018 if(!isWasmInitialized) {
34019 throw new Error("initializeWasm() must be awaited first!");
34021 const nativeResponseValue = wasm.TS_TxComplete_read(ser);
34022 return nativeResponseValue;
34024 // struct LDKCVec_u8Z TxSignatures_write(const struct LDKTxSignatures *NONNULL_PTR obj);
34026 export function TxSignatures_write(obj: bigint): number {
34027 if(!isWasmInitialized) {
34028 throw new Error("initializeWasm() must be awaited first!");
34030 const nativeResponseValue = wasm.TS_TxSignatures_write(obj);
34031 return nativeResponseValue;
34033 // struct LDKCResult_TxSignaturesDecodeErrorZ TxSignatures_read(struct LDKu8slice ser);
34035 export function TxSignatures_read(ser: number): bigint {
34036 if(!isWasmInitialized) {
34037 throw new Error("initializeWasm() must be awaited first!");
34039 const nativeResponseValue = wasm.TS_TxSignatures_read(ser);
34040 return nativeResponseValue;
34042 // struct LDKCVec_u8Z TxInitRbf_write(const struct LDKTxInitRbf *NONNULL_PTR obj);
34044 export function TxInitRbf_write(obj: bigint): number {
34045 if(!isWasmInitialized) {
34046 throw new Error("initializeWasm() must be awaited first!");
34048 const nativeResponseValue = wasm.TS_TxInitRbf_write(obj);
34049 return nativeResponseValue;
34051 // struct LDKCResult_TxInitRbfDecodeErrorZ TxInitRbf_read(struct LDKu8slice ser);
34053 export function TxInitRbf_read(ser: number): bigint {
34054 if(!isWasmInitialized) {
34055 throw new Error("initializeWasm() must be awaited first!");
34057 const nativeResponseValue = wasm.TS_TxInitRbf_read(ser);
34058 return nativeResponseValue;
34060 // struct LDKCVec_u8Z TxAckRbf_write(const struct LDKTxAckRbf *NONNULL_PTR obj);
34062 export function TxAckRbf_write(obj: bigint): number {
34063 if(!isWasmInitialized) {
34064 throw new Error("initializeWasm() must be awaited first!");
34066 const nativeResponseValue = wasm.TS_TxAckRbf_write(obj);
34067 return nativeResponseValue;
34069 // struct LDKCResult_TxAckRbfDecodeErrorZ TxAckRbf_read(struct LDKu8slice ser);
34071 export function TxAckRbf_read(ser: number): bigint {
34072 if(!isWasmInitialized) {
34073 throw new Error("initializeWasm() must be awaited first!");
34075 const nativeResponseValue = wasm.TS_TxAckRbf_read(ser);
34076 return nativeResponseValue;
34078 // struct LDKCVec_u8Z TxAbort_write(const struct LDKTxAbort *NONNULL_PTR obj);
34080 export function TxAbort_write(obj: bigint): number {
34081 if(!isWasmInitialized) {
34082 throw new Error("initializeWasm() must be awaited first!");
34084 const nativeResponseValue = wasm.TS_TxAbort_write(obj);
34085 return nativeResponseValue;
34087 // struct LDKCResult_TxAbortDecodeErrorZ TxAbort_read(struct LDKu8slice ser);
34089 export function TxAbort_read(ser: number): bigint {
34090 if(!isWasmInitialized) {
34091 throw new Error("initializeWasm() must be awaited first!");
34093 const nativeResponseValue = wasm.TS_TxAbort_read(ser);
34094 return nativeResponseValue;
34096 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
34098 export function AnnouncementSignatures_write(obj: bigint): number {
34099 if(!isWasmInitialized) {
34100 throw new Error("initializeWasm() must be awaited first!");
34102 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
34103 return nativeResponseValue;
34105 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
34107 export function AnnouncementSignatures_read(ser: number): bigint {
34108 if(!isWasmInitialized) {
34109 throw new Error("initializeWasm() must be awaited first!");
34111 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
34112 return nativeResponseValue;
34114 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
34116 export function ChannelReestablish_write(obj: bigint): number {
34117 if(!isWasmInitialized) {
34118 throw new Error("initializeWasm() must be awaited first!");
34120 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
34121 return nativeResponseValue;
34123 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
34125 export function ChannelReestablish_read(ser: number): bigint {
34126 if(!isWasmInitialized) {
34127 throw new Error("initializeWasm() must be awaited first!");
34129 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
34130 return nativeResponseValue;
34132 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
34134 export function ClosingSigned_write(obj: bigint): number {
34135 if(!isWasmInitialized) {
34136 throw new Error("initializeWasm() must be awaited first!");
34138 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
34139 return nativeResponseValue;
34141 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
34143 export function ClosingSigned_read(ser: number): bigint {
34144 if(!isWasmInitialized) {
34145 throw new Error("initializeWasm() must be awaited first!");
34147 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
34148 return nativeResponseValue;
34150 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
34152 export function ClosingSignedFeeRange_write(obj: bigint): number {
34153 if(!isWasmInitialized) {
34154 throw new Error("initializeWasm() must be awaited first!");
34156 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
34157 return nativeResponseValue;
34159 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
34161 export function ClosingSignedFeeRange_read(ser: number): bigint {
34162 if(!isWasmInitialized) {
34163 throw new Error("initializeWasm() must be awaited first!");
34165 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
34166 return nativeResponseValue;
34168 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
34170 export function CommitmentSigned_write(obj: bigint): number {
34171 if(!isWasmInitialized) {
34172 throw new Error("initializeWasm() must be awaited first!");
34174 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
34175 return nativeResponseValue;
34177 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
34179 export function CommitmentSigned_read(ser: number): bigint {
34180 if(!isWasmInitialized) {
34181 throw new Error("initializeWasm() must be awaited first!");
34183 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
34184 return nativeResponseValue;
34186 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
34188 export function FundingCreated_write(obj: bigint): number {
34189 if(!isWasmInitialized) {
34190 throw new Error("initializeWasm() must be awaited first!");
34192 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
34193 return nativeResponseValue;
34195 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
34197 export function FundingCreated_read(ser: number): bigint {
34198 if(!isWasmInitialized) {
34199 throw new Error("initializeWasm() must be awaited first!");
34201 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
34202 return nativeResponseValue;
34204 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
34206 export function FundingSigned_write(obj: bigint): number {
34207 if(!isWasmInitialized) {
34208 throw new Error("initializeWasm() must be awaited first!");
34210 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
34211 return nativeResponseValue;
34213 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
34215 export function FundingSigned_read(ser: number): bigint {
34216 if(!isWasmInitialized) {
34217 throw new Error("initializeWasm() must be awaited first!");
34219 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
34220 return nativeResponseValue;
34222 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
34224 export function ChannelReady_write(obj: bigint): number {
34225 if(!isWasmInitialized) {
34226 throw new Error("initializeWasm() must be awaited first!");
34228 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
34229 return nativeResponseValue;
34231 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
34233 export function ChannelReady_read(ser: number): bigint {
34234 if(!isWasmInitialized) {
34235 throw new Error("initializeWasm() must be awaited first!");
34237 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
34238 return nativeResponseValue;
34240 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
34242 export function Init_write(obj: bigint): number {
34243 if(!isWasmInitialized) {
34244 throw new Error("initializeWasm() must be awaited first!");
34246 const nativeResponseValue = wasm.TS_Init_write(obj);
34247 return nativeResponseValue;
34249 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
34251 export function Init_read(ser: number): bigint {
34252 if(!isWasmInitialized) {
34253 throw new Error("initializeWasm() must be awaited first!");
34255 const nativeResponseValue = wasm.TS_Init_read(ser);
34256 return nativeResponseValue;
34258 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
34260 export function OpenChannel_write(obj: bigint): number {
34261 if(!isWasmInitialized) {
34262 throw new Error("initializeWasm() must be awaited first!");
34264 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
34265 return nativeResponseValue;
34267 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
34269 export function OpenChannel_read(ser: number): bigint {
34270 if(!isWasmInitialized) {
34271 throw new Error("initializeWasm() must be awaited first!");
34273 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
34274 return nativeResponseValue;
34276 // struct LDKCVec_u8Z OpenChannelV2_write(const struct LDKOpenChannelV2 *NONNULL_PTR obj);
34278 export function OpenChannelV2_write(obj: bigint): number {
34279 if(!isWasmInitialized) {
34280 throw new Error("initializeWasm() must be awaited first!");
34282 const nativeResponseValue = wasm.TS_OpenChannelV2_write(obj);
34283 return nativeResponseValue;
34285 // struct LDKCResult_OpenChannelV2DecodeErrorZ OpenChannelV2_read(struct LDKu8slice ser);
34287 export function OpenChannelV2_read(ser: number): bigint {
34288 if(!isWasmInitialized) {
34289 throw new Error("initializeWasm() must be awaited first!");
34291 const nativeResponseValue = wasm.TS_OpenChannelV2_read(ser);
34292 return nativeResponseValue;
34294 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
34296 export function RevokeAndACK_write(obj: bigint): number {
34297 if(!isWasmInitialized) {
34298 throw new Error("initializeWasm() must be awaited first!");
34300 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
34301 return nativeResponseValue;
34303 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
34305 export function RevokeAndACK_read(ser: number): bigint {
34306 if(!isWasmInitialized) {
34307 throw new Error("initializeWasm() must be awaited first!");
34309 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
34310 return nativeResponseValue;
34312 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
34314 export function Shutdown_write(obj: bigint): number {
34315 if(!isWasmInitialized) {
34316 throw new Error("initializeWasm() must be awaited first!");
34318 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
34319 return nativeResponseValue;
34321 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
34323 export function Shutdown_read(ser: number): bigint {
34324 if(!isWasmInitialized) {
34325 throw new Error("initializeWasm() must be awaited first!");
34327 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
34328 return nativeResponseValue;
34330 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
34332 export function UpdateFailHTLC_write(obj: bigint): number {
34333 if(!isWasmInitialized) {
34334 throw new Error("initializeWasm() must be awaited first!");
34336 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
34337 return nativeResponseValue;
34339 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
34341 export function UpdateFailHTLC_read(ser: number): bigint {
34342 if(!isWasmInitialized) {
34343 throw new Error("initializeWasm() must be awaited first!");
34345 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
34346 return nativeResponseValue;
34348 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
34350 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
34351 if(!isWasmInitialized) {
34352 throw new Error("initializeWasm() must be awaited first!");
34354 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
34355 return nativeResponseValue;
34357 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
34359 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
34360 if(!isWasmInitialized) {
34361 throw new Error("initializeWasm() must be awaited first!");
34363 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
34364 return nativeResponseValue;
34366 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
34368 export function UpdateFee_write(obj: bigint): number {
34369 if(!isWasmInitialized) {
34370 throw new Error("initializeWasm() must be awaited first!");
34372 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
34373 return nativeResponseValue;
34375 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
34377 export function UpdateFee_read(ser: number): bigint {
34378 if(!isWasmInitialized) {
34379 throw new Error("initializeWasm() must be awaited first!");
34381 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
34382 return nativeResponseValue;
34384 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
34386 export function UpdateFulfillHTLC_write(obj: bigint): number {
34387 if(!isWasmInitialized) {
34388 throw new Error("initializeWasm() must be awaited first!");
34390 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
34391 return nativeResponseValue;
34393 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
34395 export function UpdateFulfillHTLC_read(ser: number): bigint {
34396 if(!isWasmInitialized) {
34397 throw new Error("initializeWasm() must be awaited first!");
34399 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
34400 return nativeResponseValue;
34402 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
34404 export function UpdateAddHTLC_write(obj: bigint): number {
34405 if(!isWasmInitialized) {
34406 throw new Error("initializeWasm() must be awaited first!");
34408 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
34409 return nativeResponseValue;
34411 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
34413 export function UpdateAddHTLC_read(ser: number): bigint {
34414 if(!isWasmInitialized) {
34415 throw new Error("initializeWasm() must be awaited first!");
34417 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
34418 return nativeResponseValue;
34420 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
34422 export function OnionMessage_read(ser: number): bigint {
34423 if(!isWasmInitialized) {
34424 throw new Error("initializeWasm() must be awaited first!");
34426 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
34427 return nativeResponseValue;
34429 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
34431 export function OnionMessage_write(obj: bigint): number {
34432 if(!isWasmInitialized) {
34433 throw new Error("initializeWasm() must be awaited first!");
34435 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
34436 return nativeResponseValue;
34438 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
34440 export function Ping_write(obj: bigint): number {
34441 if(!isWasmInitialized) {
34442 throw new Error("initializeWasm() must be awaited first!");
34444 const nativeResponseValue = wasm.TS_Ping_write(obj);
34445 return nativeResponseValue;
34447 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
34449 export function Ping_read(ser: number): bigint {
34450 if(!isWasmInitialized) {
34451 throw new Error("initializeWasm() must be awaited first!");
34453 const nativeResponseValue = wasm.TS_Ping_read(ser);
34454 return nativeResponseValue;
34456 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
34458 export function Pong_write(obj: bigint): number {
34459 if(!isWasmInitialized) {
34460 throw new Error("initializeWasm() must be awaited first!");
34462 const nativeResponseValue = wasm.TS_Pong_write(obj);
34463 return nativeResponseValue;
34465 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
34467 export function Pong_read(ser: number): bigint {
34468 if(!isWasmInitialized) {
34469 throw new Error("initializeWasm() must be awaited first!");
34471 const nativeResponseValue = wasm.TS_Pong_read(ser);
34472 return nativeResponseValue;
34474 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
34476 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
34477 if(!isWasmInitialized) {
34478 throw new Error("initializeWasm() must be awaited first!");
34480 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
34481 return nativeResponseValue;
34483 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
34485 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
34486 if(!isWasmInitialized) {
34487 throw new Error("initializeWasm() must be awaited first!");
34489 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
34490 return nativeResponseValue;
34492 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
34494 export function ChannelAnnouncement_write(obj: bigint): number {
34495 if(!isWasmInitialized) {
34496 throw new Error("initializeWasm() must be awaited first!");
34498 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
34499 return nativeResponseValue;
34501 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
34503 export function ChannelAnnouncement_read(ser: number): bigint {
34504 if(!isWasmInitialized) {
34505 throw new Error("initializeWasm() must be awaited first!");
34507 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
34508 return nativeResponseValue;
34510 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
34512 export function UnsignedChannelUpdate_write(obj: bigint): number {
34513 if(!isWasmInitialized) {
34514 throw new Error("initializeWasm() must be awaited first!");
34516 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
34517 return nativeResponseValue;
34519 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
34521 export function UnsignedChannelUpdate_read(ser: number): bigint {
34522 if(!isWasmInitialized) {
34523 throw new Error("initializeWasm() must be awaited first!");
34525 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
34526 return nativeResponseValue;
34528 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
34530 export function ChannelUpdate_write(obj: bigint): number {
34531 if(!isWasmInitialized) {
34532 throw new Error("initializeWasm() must be awaited first!");
34534 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
34535 return nativeResponseValue;
34537 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
34539 export function ChannelUpdate_read(ser: number): bigint {
34540 if(!isWasmInitialized) {
34541 throw new Error("initializeWasm() must be awaited first!");
34543 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
34544 return nativeResponseValue;
34546 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
34548 export function ErrorMessage_write(obj: bigint): number {
34549 if(!isWasmInitialized) {
34550 throw new Error("initializeWasm() must be awaited first!");
34552 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
34553 return nativeResponseValue;
34555 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
34557 export function ErrorMessage_read(ser: number): bigint {
34558 if(!isWasmInitialized) {
34559 throw new Error("initializeWasm() must be awaited first!");
34561 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
34562 return nativeResponseValue;
34564 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
34566 export function WarningMessage_write(obj: bigint): number {
34567 if(!isWasmInitialized) {
34568 throw new Error("initializeWasm() must be awaited first!");
34570 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
34571 return nativeResponseValue;
34573 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
34575 export function WarningMessage_read(ser: number): bigint {
34576 if(!isWasmInitialized) {
34577 throw new Error("initializeWasm() must be awaited first!");
34579 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
34580 return nativeResponseValue;
34582 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
34584 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
34585 if(!isWasmInitialized) {
34586 throw new Error("initializeWasm() must be awaited first!");
34588 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
34589 return nativeResponseValue;
34591 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
34593 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
34594 if(!isWasmInitialized) {
34595 throw new Error("initializeWasm() must be awaited first!");
34597 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
34598 return nativeResponseValue;
34600 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
34602 export function NodeAnnouncement_write(obj: bigint): number {
34603 if(!isWasmInitialized) {
34604 throw new Error("initializeWasm() must be awaited first!");
34606 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
34607 return nativeResponseValue;
34609 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
34611 export function NodeAnnouncement_read(ser: number): bigint {
34612 if(!isWasmInitialized) {
34613 throw new Error("initializeWasm() must be awaited first!");
34615 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
34616 return nativeResponseValue;
34618 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
34620 export function QueryShortChannelIds_read(ser: number): bigint {
34621 if(!isWasmInitialized) {
34622 throw new Error("initializeWasm() must be awaited first!");
34624 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
34625 return nativeResponseValue;
34627 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
34629 export function QueryShortChannelIds_write(obj: bigint): number {
34630 if(!isWasmInitialized) {
34631 throw new Error("initializeWasm() must be awaited first!");
34633 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
34634 return nativeResponseValue;
34636 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
34638 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
34639 if(!isWasmInitialized) {
34640 throw new Error("initializeWasm() must be awaited first!");
34642 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
34643 return nativeResponseValue;
34645 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
34647 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
34648 if(!isWasmInitialized) {
34649 throw new Error("initializeWasm() must be awaited first!");
34651 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
34652 return nativeResponseValue;
34654 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
34656 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
34657 if(!isWasmInitialized) {
34658 throw new Error("initializeWasm() must be awaited first!");
34660 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
34661 return nativeResponseValue;
34663 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
34665 export function QueryChannelRange_write(obj: bigint): number {
34666 if(!isWasmInitialized) {
34667 throw new Error("initializeWasm() must be awaited first!");
34669 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
34670 return nativeResponseValue;
34672 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
34674 export function QueryChannelRange_read(ser: number): bigint {
34675 if(!isWasmInitialized) {
34676 throw new Error("initializeWasm() must be awaited first!");
34678 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
34679 return nativeResponseValue;
34681 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
34683 export function ReplyChannelRange_read(ser: number): bigint {
34684 if(!isWasmInitialized) {
34685 throw new Error("initializeWasm() must be awaited first!");
34687 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
34688 return nativeResponseValue;
34690 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
34692 export function ReplyChannelRange_write(obj: bigint): number {
34693 if(!isWasmInitialized) {
34694 throw new Error("initializeWasm() must be awaited first!");
34696 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
34697 return nativeResponseValue;
34699 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
34701 export function GossipTimestampFilter_write(obj: bigint): number {
34702 if(!isWasmInitialized) {
34703 throw new Error("initializeWasm() must be awaited first!");
34705 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
34706 return nativeResponseValue;
34708 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
34710 export function GossipTimestampFilter_read(ser: number): bigint {
34711 if(!isWasmInitialized) {
34712 throw new Error("initializeWasm() must be awaited first!");
34714 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
34715 return nativeResponseValue;
34717 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
34719 export function CustomMessageHandler_free(this_ptr: bigint): void {
34720 if(!isWasmInitialized) {
34721 throw new Error("initializeWasm() must be awaited first!");
34723 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
34724 // debug statements here
34726 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
34728 export function IgnoringMessageHandler_free(this_obj: bigint): void {
34729 if(!isWasmInitialized) {
34730 throw new Error("initializeWasm() must be awaited first!");
34732 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
34733 // debug statements here
34735 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
34737 export function IgnoringMessageHandler_new(): bigint {
34738 if(!isWasmInitialized) {
34739 throw new Error("initializeWasm() must be awaited first!");
34741 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
34742 return nativeResponseValue;
34744 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34746 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
34747 if(!isWasmInitialized) {
34748 throw new Error("initializeWasm() must be awaited first!");
34750 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
34751 return nativeResponseValue;
34753 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34755 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
34756 if(!isWasmInitialized) {
34757 throw new Error("initializeWasm() must be awaited first!");
34759 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
34760 return nativeResponseValue;
34762 // struct LDKOnionMessageProvider IgnoringMessageHandler_as_OnionMessageProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34764 export function IgnoringMessageHandler_as_OnionMessageProvider(this_arg: bigint): bigint {
34765 if(!isWasmInitialized) {
34766 throw new Error("initializeWasm() must be awaited first!");
34768 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageProvider(this_arg);
34769 return nativeResponseValue;
34771 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34773 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
34774 if(!isWasmInitialized) {
34775 throw new Error("initializeWasm() must be awaited first!");
34777 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
34778 return nativeResponseValue;
34780 // struct LDKOffersMessageHandler IgnoringMessageHandler_as_OffersMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34782 export function IgnoringMessageHandler_as_OffersMessageHandler(this_arg: bigint): bigint {
34783 if(!isWasmInitialized) {
34784 throw new Error("initializeWasm() must be awaited first!");
34786 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OffersMessageHandler(this_arg);
34787 return nativeResponseValue;
34789 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34791 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
34792 if(!isWasmInitialized) {
34793 throw new Error("initializeWasm() must be awaited first!");
34795 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
34796 return nativeResponseValue;
34798 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34800 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
34801 if(!isWasmInitialized) {
34802 throw new Error("initializeWasm() must be awaited first!");
34804 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
34805 return nativeResponseValue;
34807 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
34809 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
34810 if(!isWasmInitialized) {
34811 throw new Error("initializeWasm() must be awaited first!");
34813 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
34814 return nativeResponseValue;
34816 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
34818 export function ErroringMessageHandler_free(this_obj: bigint): void {
34819 if(!isWasmInitialized) {
34820 throw new Error("initializeWasm() must be awaited first!");
34822 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
34823 // debug statements here
34825 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
34827 export function ErroringMessageHandler_new(): bigint {
34828 if(!isWasmInitialized) {
34829 throw new Error("initializeWasm() must be awaited first!");
34831 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
34832 return nativeResponseValue;
34834 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
34836 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
34837 if(!isWasmInitialized) {
34838 throw new Error("initializeWasm() must be awaited first!");
34840 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
34841 return nativeResponseValue;
34843 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
34845 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
34846 if(!isWasmInitialized) {
34847 throw new Error("initializeWasm() must be awaited first!");
34849 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
34850 return nativeResponseValue;
34852 // void MessageHandler_free(struct LDKMessageHandler this_obj);
34854 export function MessageHandler_free(this_obj: bigint): void {
34855 if(!isWasmInitialized) {
34856 throw new Error("initializeWasm() must be awaited first!");
34858 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
34859 // debug statements here
34861 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
34863 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
34864 if(!isWasmInitialized) {
34865 throw new Error("initializeWasm() must be awaited first!");
34867 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
34868 return nativeResponseValue;
34870 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
34872 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
34873 if(!isWasmInitialized) {
34874 throw new Error("initializeWasm() must be awaited first!");
34876 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
34877 // debug statements here
34879 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
34881 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
34882 if(!isWasmInitialized) {
34883 throw new Error("initializeWasm() must be awaited first!");
34885 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
34886 return nativeResponseValue;
34888 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
34890 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
34891 if(!isWasmInitialized) {
34892 throw new Error("initializeWasm() must be awaited first!");
34894 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
34895 // debug statements here
34897 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
34899 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
34900 if(!isWasmInitialized) {
34901 throw new Error("initializeWasm() must be awaited first!");
34903 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
34904 return nativeResponseValue;
34906 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
34908 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
34909 if(!isWasmInitialized) {
34910 throw new Error("initializeWasm() must be awaited first!");
34912 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
34913 // debug statements here
34915 // const struct LDKCustomMessageHandler *MessageHandler_get_custom_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
34917 export function MessageHandler_get_custom_message_handler(this_ptr: bigint): bigint {
34918 if(!isWasmInitialized) {
34919 throw new Error("initializeWasm() must be awaited first!");
34921 const nativeResponseValue = wasm.TS_MessageHandler_get_custom_message_handler(this_ptr);
34922 return nativeResponseValue;
34924 // void MessageHandler_set_custom_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKCustomMessageHandler val);
34926 export function MessageHandler_set_custom_message_handler(this_ptr: bigint, val: bigint): void {
34927 if(!isWasmInitialized) {
34928 throw new Error("initializeWasm() must be awaited first!");
34930 const nativeResponseValue = wasm.TS_MessageHandler_set_custom_message_handler(this_ptr, val);
34931 // debug statements here
34933 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg, struct LDKOnionMessageHandler onion_message_handler_arg, struct LDKCustomMessageHandler custom_message_handler_arg);
34935 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint, custom_message_handler_arg: bigint): bigint {
34936 if(!isWasmInitialized) {
34937 throw new Error("initializeWasm() must be awaited first!");
34939 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg, custom_message_handler_arg);
34940 return nativeResponseValue;
34942 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
34944 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
34945 if(!isWasmInitialized) {
34946 throw new Error("initializeWasm() must be awaited first!");
34948 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
34949 return nativeResponseValue;
34951 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
34953 export function SocketDescriptor_clone(orig: bigint): bigint {
34954 if(!isWasmInitialized) {
34955 throw new Error("initializeWasm() must be awaited first!");
34957 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
34958 return nativeResponseValue;
34960 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
34962 export function SocketDescriptor_free(this_ptr: bigint): void {
34963 if(!isWasmInitialized) {
34964 throw new Error("initializeWasm() must be awaited first!");
34966 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
34967 // debug statements here
34969 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
34971 export function PeerHandleError_free(this_obj: bigint): void {
34972 if(!isWasmInitialized) {
34973 throw new Error("initializeWasm() must be awaited first!");
34975 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
34976 // debug statements here
34978 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(void);
34980 export function PeerHandleError_new(): bigint {
34981 if(!isWasmInitialized) {
34982 throw new Error("initializeWasm() must be awaited first!");
34984 const nativeResponseValue = wasm.TS_PeerHandleError_new();
34985 return nativeResponseValue;
34987 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
34989 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
34990 if(!isWasmInitialized) {
34991 throw new Error("initializeWasm() must be awaited first!");
34993 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
34994 return nativeResponseValue;
34996 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
34998 export function PeerHandleError_clone(orig: bigint): bigint {
34999 if(!isWasmInitialized) {
35000 throw new Error("initializeWasm() must be awaited first!");
35002 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
35003 return nativeResponseValue;
35005 // void PeerManager_free(struct LDKPeerManager this_obj);
35007 export function PeerManager_free(this_obj: bigint): void {
35008 if(!isWasmInitialized) {
35009 throw new Error("initializeWasm() must be awaited first!");
35011 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
35012 // debug statements here
35014 // 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 LDKNodeSigner node_signer);
35016 export function PeerManager_new(message_handler: bigint, current_time: number, ephemeral_random_data: number, logger: bigint, node_signer: bigint): bigint {
35017 if(!isWasmInitialized) {
35018 throw new Error("initializeWasm() must be awaited first!");
35020 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, current_time, ephemeral_random_data, logger, node_signer);
35021 return nativeResponseValue;
35023 // MUST_USE_RES struct LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
35025 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
35026 if(!isWasmInitialized) {
35027 throw new Error("initializeWasm() must be awaited first!");
35029 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
35030 return nativeResponseValue;
35032 // 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);
35034 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
35035 if(!isWasmInitialized) {
35036 throw new Error("initializeWasm() must be awaited first!");
35038 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
35039 return nativeResponseValue;
35041 // 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);
35043 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
35044 if(!isWasmInitialized) {
35045 throw new Error("initializeWasm() must be awaited first!");
35047 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
35048 return nativeResponseValue;
35050 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
35052 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
35053 if(!isWasmInitialized) {
35054 throw new Error("initializeWasm() must be awaited first!");
35056 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
35057 return nativeResponseValue;
35059 // 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);
35061 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
35062 if(!isWasmInitialized) {
35063 throw new Error("initializeWasm() must be awaited first!");
35065 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
35066 return nativeResponseValue;
35068 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
35070 export function PeerManager_process_events(this_arg: bigint): void {
35071 if(!isWasmInitialized) {
35072 throw new Error("initializeWasm() must be awaited first!");
35074 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
35075 // debug statements here
35077 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
35079 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
35080 if(!isWasmInitialized) {
35081 throw new Error("initializeWasm() must be awaited first!");
35083 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
35084 // debug statements here
35086 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
35088 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number): void {
35089 if(!isWasmInitialized) {
35090 throw new Error("initializeWasm() must be awaited first!");
35092 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id);
35093 // debug statements here
35095 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
35097 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
35098 if(!isWasmInitialized) {
35099 throw new Error("initializeWasm() must be awaited first!");
35101 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
35102 // debug statements here
35104 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
35106 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
35107 if(!isWasmInitialized) {
35108 throw new Error("initializeWasm() must be awaited first!");
35110 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
35111 // debug statements here
35113 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
35115 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
35116 if(!isWasmInitialized) {
35117 throw new Error("initializeWasm() must be awaited first!");
35119 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
35120 // debug statements here
35122 // uint64_t htlc_success_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
35124 export function htlc_success_tx_weight(channel_type_features: bigint): bigint {
35125 if(!isWasmInitialized) {
35126 throw new Error("initializeWasm() must be awaited first!");
35128 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(channel_type_features);
35129 return nativeResponseValue;
35131 // uint64_t htlc_timeout_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
35133 export function htlc_timeout_tx_weight(channel_type_features: bigint): bigint {
35134 if(!isWasmInitialized) {
35135 throw new Error("initializeWasm() must be awaited first!");
35137 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(channel_type_features);
35138 return nativeResponseValue;
35140 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
35142 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
35143 if(!isWasmInitialized) {
35144 throw new Error("initializeWasm() must be awaited first!");
35146 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
35147 return nativeResponseValue;
35149 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
35151 export function HTLCClaim_offered_timeout(): HTLCClaim {
35152 if(!isWasmInitialized) {
35153 throw new Error("initializeWasm() must be awaited first!");
35155 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
35156 return nativeResponseValue;
35158 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
35160 export function HTLCClaim_offered_preimage(): HTLCClaim {
35161 if(!isWasmInitialized) {
35162 throw new Error("initializeWasm() must be awaited first!");
35164 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
35165 return nativeResponseValue;
35167 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
35169 export function HTLCClaim_accepted_timeout(): HTLCClaim {
35170 if(!isWasmInitialized) {
35171 throw new Error("initializeWasm() must be awaited first!");
35173 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
35174 return nativeResponseValue;
35176 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
35178 export function HTLCClaim_accepted_preimage(): HTLCClaim {
35179 if(!isWasmInitialized) {
35180 throw new Error("initializeWasm() must be awaited first!");
35182 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
35183 return nativeResponseValue;
35185 // enum LDKHTLCClaim HTLCClaim_revocation(void);
35187 export function HTLCClaim_revocation(): HTLCClaim {
35188 if(!isWasmInitialized) {
35189 throw new Error("initializeWasm() must be awaited first!");
35191 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
35192 return nativeResponseValue;
35194 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
35196 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
35197 if(!isWasmInitialized) {
35198 throw new Error("initializeWasm() must be awaited first!");
35200 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
35201 return nativeResponseValue;
35203 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
35205 export function HTLCClaim_from_witness(witness: number): bigint {
35206 if(!isWasmInitialized) {
35207 throw new Error("initializeWasm() must be awaited first!");
35209 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
35210 return nativeResponseValue;
35212 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
35214 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
35215 if(!isWasmInitialized) {
35216 throw new Error("initializeWasm() must be awaited first!");
35218 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
35219 return nativeResponseValue;
35221 // 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);
35223 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 {
35224 if(!isWasmInitialized) {
35225 throw new Error("initializeWasm() must be awaited first!");
35227 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
35228 return nativeResponseValue;
35230 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
35232 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
35233 if(!isWasmInitialized) {
35234 throw new Error("initializeWasm() must be awaited first!");
35236 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
35237 // debug statements here
35239 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
35241 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
35242 if(!isWasmInitialized) {
35243 throw new Error("initializeWasm() must be awaited first!");
35245 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
35246 return nativeResponseValue;
35248 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
35250 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
35251 if(!isWasmInitialized) {
35252 throw new Error("initializeWasm() must be awaited first!");
35254 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
35255 return nativeResponseValue;
35257 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
35259 export function CounterpartyCommitmentSecrets_new(): bigint {
35260 if(!isWasmInitialized) {
35261 throw new Error("initializeWasm() must be awaited first!");
35263 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
35264 return nativeResponseValue;
35266 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
35268 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
35269 if(!isWasmInitialized) {
35270 throw new Error("initializeWasm() must be awaited first!");
35272 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
35273 return nativeResponseValue;
35275 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
35277 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
35278 if(!isWasmInitialized) {
35279 throw new Error("initializeWasm() must be awaited first!");
35281 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
35282 return nativeResponseValue;
35284 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
35286 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
35287 if(!isWasmInitialized) {
35288 throw new Error("initializeWasm() must be awaited first!");
35290 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
35291 return nativeResponseValue;
35293 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
35295 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
35296 if(!isWasmInitialized) {
35297 throw new Error("initializeWasm() must be awaited first!");
35299 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
35300 return nativeResponseValue;
35302 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
35304 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
35305 if(!isWasmInitialized) {
35306 throw new Error("initializeWasm() must be awaited first!");
35308 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
35309 return nativeResponseValue;
35311 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
35313 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
35314 if(!isWasmInitialized) {
35315 throw new Error("initializeWasm() must be awaited first!");
35317 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
35318 return nativeResponseValue;
35320 // struct LDKPublicKey derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
35322 export function derive_public_key(per_commitment_point: number, base_point: number): number {
35323 if(!isWasmInitialized) {
35324 throw new Error("initializeWasm() must be awaited first!");
35326 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
35327 return nativeResponseValue;
35329 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
35331 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
35332 if(!isWasmInitialized) {
35333 throw new Error("initializeWasm() must be awaited first!");
35335 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
35336 return nativeResponseValue;
35338 // struct LDKPublicKey derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
35340 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
35341 if(!isWasmInitialized) {
35342 throw new Error("initializeWasm() must be awaited first!");
35344 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
35345 return nativeResponseValue;
35347 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
35349 export function TxCreationKeys_free(this_obj: bigint): void {
35350 if(!isWasmInitialized) {
35351 throw new Error("initializeWasm() must be awaited first!");
35353 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
35354 // debug statements here
35356 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
35358 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
35359 if(!isWasmInitialized) {
35360 throw new Error("initializeWasm() must be awaited first!");
35362 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
35363 return nativeResponseValue;
35365 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35367 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
35368 if(!isWasmInitialized) {
35369 throw new Error("initializeWasm() must be awaited first!");
35371 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
35372 // debug statements here
35374 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
35376 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
35377 if(!isWasmInitialized) {
35378 throw new Error("initializeWasm() must be awaited first!");
35380 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
35381 return nativeResponseValue;
35383 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35385 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
35386 if(!isWasmInitialized) {
35387 throw new Error("initializeWasm() must be awaited first!");
35389 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
35390 // debug statements here
35392 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
35394 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
35395 if(!isWasmInitialized) {
35396 throw new Error("initializeWasm() must be awaited first!");
35398 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
35399 return nativeResponseValue;
35401 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35403 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
35404 if(!isWasmInitialized) {
35405 throw new Error("initializeWasm() must be awaited first!");
35407 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
35408 // debug statements here
35410 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
35412 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
35413 if(!isWasmInitialized) {
35414 throw new Error("initializeWasm() must be awaited first!");
35416 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
35417 return nativeResponseValue;
35419 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35421 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
35422 if(!isWasmInitialized) {
35423 throw new Error("initializeWasm() must be awaited first!");
35425 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
35426 // debug statements here
35428 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
35430 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
35431 if(!isWasmInitialized) {
35432 throw new Error("initializeWasm() must be awaited first!");
35434 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
35435 return nativeResponseValue;
35437 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35439 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
35440 if(!isWasmInitialized) {
35441 throw new Error("initializeWasm() must be awaited first!");
35443 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
35444 // debug statements here
35446 // 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);
35448 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 {
35449 if(!isWasmInitialized) {
35450 throw new Error("initializeWasm() must be awaited first!");
35452 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);
35453 return nativeResponseValue;
35455 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
35457 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
35458 if(!isWasmInitialized) {
35459 throw new Error("initializeWasm() must be awaited first!");
35461 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
35462 return nativeResponseValue;
35464 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
35466 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
35467 if(!isWasmInitialized) {
35468 throw new Error("initializeWasm() must be awaited first!");
35470 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
35471 return nativeResponseValue;
35473 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
35475 export function TxCreationKeys_clone(orig: bigint): bigint {
35476 if(!isWasmInitialized) {
35477 throw new Error("initializeWasm() must be awaited first!");
35479 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
35480 return nativeResponseValue;
35482 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
35484 export function TxCreationKeys_write(obj: bigint): number {
35485 if(!isWasmInitialized) {
35486 throw new Error("initializeWasm() must be awaited first!");
35488 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
35489 return nativeResponseValue;
35491 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
35493 export function TxCreationKeys_read(ser: number): bigint {
35494 if(!isWasmInitialized) {
35495 throw new Error("initializeWasm() must be awaited first!");
35497 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
35498 return nativeResponseValue;
35500 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
35502 export function ChannelPublicKeys_free(this_obj: bigint): void {
35503 if(!isWasmInitialized) {
35504 throw new Error("initializeWasm() must be awaited first!");
35506 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
35507 // debug statements here
35509 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
35511 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
35512 if(!isWasmInitialized) {
35513 throw new Error("initializeWasm() must be awaited first!");
35515 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
35516 return nativeResponseValue;
35518 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35520 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
35521 if(!isWasmInitialized) {
35522 throw new Error("initializeWasm() must be awaited first!");
35524 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
35525 // debug statements here
35527 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
35529 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
35530 if(!isWasmInitialized) {
35531 throw new Error("initializeWasm() must be awaited first!");
35533 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
35534 return nativeResponseValue;
35536 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35538 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
35539 if(!isWasmInitialized) {
35540 throw new Error("initializeWasm() must be awaited first!");
35542 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
35543 // debug statements here
35545 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
35547 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
35548 if(!isWasmInitialized) {
35549 throw new Error("initializeWasm() must be awaited first!");
35551 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
35552 return nativeResponseValue;
35554 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35556 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
35557 if(!isWasmInitialized) {
35558 throw new Error("initializeWasm() must be awaited first!");
35560 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
35561 // debug statements here
35563 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
35565 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
35566 if(!isWasmInitialized) {
35567 throw new Error("initializeWasm() must be awaited first!");
35569 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
35570 return nativeResponseValue;
35572 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35574 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
35575 if(!isWasmInitialized) {
35576 throw new Error("initializeWasm() must be awaited first!");
35578 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
35579 // debug statements here
35581 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
35583 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
35584 if(!isWasmInitialized) {
35585 throw new Error("initializeWasm() must be awaited first!");
35587 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
35588 return nativeResponseValue;
35590 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35592 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
35593 if(!isWasmInitialized) {
35594 throw new Error("initializeWasm() must be awaited first!");
35596 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
35597 // debug statements here
35599 // 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);
35601 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 {
35602 if(!isWasmInitialized) {
35603 throw new Error("initializeWasm() must be awaited first!");
35605 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
35606 return nativeResponseValue;
35608 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
35610 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
35611 if(!isWasmInitialized) {
35612 throw new Error("initializeWasm() must be awaited first!");
35614 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
35615 return nativeResponseValue;
35617 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
35619 export function ChannelPublicKeys_clone(orig: bigint): bigint {
35620 if(!isWasmInitialized) {
35621 throw new Error("initializeWasm() must be awaited first!");
35623 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
35624 return nativeResponseValue;
35626 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
35628 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
35629 if(!isWasmInitialized) {
35630 throw new Error("initializeWasm() must be awaited first!");
35632 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
35633 return nativeResponseValue;
35635 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
35637 export function ChannelPublicKeys_write(obj: bigint): number {
35638 if(!isWasmInitialized) {
35639 throw new Error("initializeWasm() must be awaited first!");
35641 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
35642 return nativeResponseValue;
35644 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
35646 export function ChannelPublicKeys_read(ser: number): bigint {
35647 if(!isWasmInitialized) {
35648 throw new Error("initializeWasm() must be awaited first!");
35650 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
35651 return nativeResponseValue;
35653 // 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);
35655 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 {
35656 if(!isWasmInitialized) {
35657 throw new Error("initializeWasm() must be awaited first!");
35659 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
35660 return nativeResponseValue;
35662 // 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);
35664 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
35665 if(!isWasmInitialized) {
35666 throw new Error("initializeWasm() must be awaited first!");
35668 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
35669 return nativeResponseValue;
35671 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
35673 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
35674 if(!isWasmInitialized) {
35675 throw new Error("initializeWasm() must be awaited first!");
35677 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
35678 return nativeResponseValue;
35680 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
35682 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
35683 if(!isWasmInitialized) {
35684 throw new Error("initializeWasm() must be awaited first!");
35686 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
35687 // debug statements here
35689 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
35691 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
35692 if(!isWasmInitialized) {
35693 throw new Error("initializeWasm() must be awaited first!");
35695 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
35696 return nativeResponseValue;
35698 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
35700 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
35701 if(!isWasmInitialized) {
35702 throw new Error("initializeWasm() must be awaited first!");
35704 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
35705 // debug statements here
35707 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
35709 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
35710 if(!isWasmInitialized) {
35711 throw new Error("initializeWasm() must be awaited first!");
35713 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
35714 return nativeResponseValue;
35716 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
35718 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
35719 if(!isWasmInitialized) {
35720 throw new Error("initializeWasm() must be awaited first!");
35722 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
35723 // debug statements here
35725 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
35727 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
35728 if(!isWasmInitialized) {
35729 throw new Error("initializeWasm() must be awaited first!");
35731 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
35732 return nativeResponseValue;
35734 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
35736 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
35737 if(!isWasmInitialized) {
35738 throw new Error("initializeWasm() must be awaited first!");
35740 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
35741 // debug statements here
35743 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
35745 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
35746 if(!isWasmInitialized) {
35747 throw new Error("initializeWasm() must be awaited first!");
35749 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
35750 return nativeResponseValue;
35752 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35754 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
35755 if(!isWasmInitialized) {
35756 throw new Error("initializeWasm() must be awaited first!");
35758 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
35759 // debug statements here
35761 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
35763 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
35764 if(!isWasmInitialized) {
35765 throw new Error("initializeWasm() must be awaited first!");
35767 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
35768 return nativeResponseValue;
35770 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
35772 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
35773 if(!isWasmInitialized) {
35774 throw new Error("initializeWasm() must be awaited first!");
35776 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
35777 // debug statements here
35779 // 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);
35781 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 {
35782 if(!isWasmInitialized) {
35783 throw new Error("initializeWasm() must be awaited first!");
35785 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
35786 return nativeResponseValue;
35788 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
35790 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
35791 if(!isWasmInitialized) {
35792 throw new Error("initializeWasm() must be awaited first!");
35794 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
35795 return nativeResponseValue;
35797 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
35799 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
35800 if(!isWasmInitialized) {
35801 throw new Error("initializeWasm() must be awaited first!");
35803 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
35804 return nativeResponseValue;
35806 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
35808 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
35809 if(!isWasmInitialized) {
35810 throw new Error("initializeWasm() must be awaited first!");
35812 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
35813 return nativeResponseValue;
35815 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
35817 export function HTLCOutputInCommitment_write(obj: bigint): number {
35818 if(!isWasmInitialized) {
35819 throw new Error("initializeWasm() must be awaited first!");
35821 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
35822 return nativeResponseValue;
35824 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
35826 export function HTLCOutputInCommitment_read(ser: number): bigint {
35827 if(!isWasmInitialized) {
35828 throw new Error("initializeWasm() must be awaited first!");
35830 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
35831 return nativeResponseValue;
35833 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, const struct LDKTxCreationKeys *NONNULL_PTR keys);
35835 export function get_htlc_redeemscript(htlc: bigint, channel_type_features: bigint, keys: bigint): number {
35836 if(!isWasmInitialized) {
35837 throw new Error("initializeWasm() must be awaited first!");
35839 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, channel_type_features, keys);
35840 return nativeResponseValue;
35842 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
35844 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
35845 if(!isWasmInitialized) {
35846 throw new Error("initializeWasm() must be awaited first!");
35848 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
35849 return nativeResponseValue;
35851 // 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, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
35853 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, channel_type_features: bigint, broadcaster_delayed_payment_key: number, revocation_key: number): number {
35854 if(!isWasmInitialized) {
35855 throw new Error("initializeWasm() must be awaited first!");
35857 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, channel_type_features, broadcaster_delayed_payment_key, revocation_key);
35858 return nativeResponseValue;
35860 // struct LDKWitness build_htlc_input_witness(struct LDKSignature local_sig, struct LDKSignature remote_sig, struct LDKCOption_PaymentPreimageZ preimage, struct LDKu8slice redeem_script, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
35862 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: bigint, redeem_script: number, channel_type_features: bigint): number {
35863 if(!isWasmInitialized) {
35864 throw new Error("initializeWasm() must be awaited first!");
35866 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, channel_type_features);
35867 return nativeResponseValue;
35869 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
35871 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
35872 if(!isWasmInitialized) {
35873 throw new Error("initializeWasm() must be awaited first!");
35875 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
35876 return nativeResponseValue;
35878 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
35880 export function get_anchor_redeemscript(funding_pubkey: number): number {
35881 if(!isWasmInitialized) {
35882 throw new Error("initializeWasm() must be awaited first!");
35884 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
35885 return nativeResponseValue;
35887 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKSignature funding_sig);
35889 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
35890 if(!isWasmInitialized) {
35891 throw new Error("initializeWasm() must be awaited first!");
35893 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
35894 return nativeResponseValue;
35896 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
35898 export function ChannelTransactionParameters_free(this_obj: bigint): void {
35899 if(!isWasmInitialized) {
35900 throw new Error("initializeWasm() must be awaited first!");
35902 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
35903 // debug statements here
35905 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
35907 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
35908 if(!isWasmInitialized) {
35909 throw new Error("initializeWasm() must be awaited first!");
35911 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
35912 return nativeResponseValue;
35914 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
35916 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
35917 if(!isWasmInitialized) {
35918 throw new Error("initializeWasm() must be awaited first!");
35920 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
35921 // debug statements here
35923 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
35925 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
35926 if(!isWasmInitialized) {
35927 throw new Error("initializeWasm() must be awaited first!");
35929 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
35930 return nativeResponseValue;
35932 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
35934 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
35935 if(!isWasmInitialized) {
35936 throw new Error("initializeWasm() must be awaited first!");
35938 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
35939 // debug statements here
35941 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
35943 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
35944 if(!isWasmInitialized) {
35945 throw new Error("initializeWasm() must be awaited first!");
35947 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
35948 return nativeResponseValue;
35950 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
35952 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
35953 if(!isWasmInitialized) {
35954 throw new Error("initializeWasm() must be awaited first!");
35956 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
35957 // debug statements here
35959 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
35961 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
35962 if(!isWasmInitialized) {
35963 throw new Error("initializeWasm() must be awaited first!");
35965 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
35966 return nativeResponseValue;
35968 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
35970 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
35971 if(!isWasmInitialized) {
35972 throw new Error("initializeWasm() must be awaited first!");
35974 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
35975 // debug statements here
35977 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
35979 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
35980 if(!isWasmInitialized) {
35981 throw new Error("initializeWasm() must be awaited first!");
35983 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
35984 return nativeResponseValue;
35986 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
35988 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
35989 if(!isWasmInitialized) {
35990 throw new Error("initializeWasm() must be awaited first!");
35992 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
35993 // debug statements here
35995 // struct LDKChannelTypeFeatures ChannelTransactionParameters_get_channel_type_features(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
35997 export function ChannelTransactionParameters_get_channel_type_features(this_ptr: bigint): bigint {
35998 if(!isWasmInitialized) {
35999 throw new Error("initializeWasm() must be awaited first!");
36001 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_channel_type_features(this_ptr);
36002 return nativeResponseValue;
36004 // void ChannelTransactionParameters_set_channel_type_features(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
36006 export function ChannelTransactionParameters_set_channel_type_features(this_ptr: bigint, val: bigint): void {
36007 if(!isWasmInitialized) {
36008 throw new Error("initializeWasm() must be awaited first!");
36010 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_channel_type_features(this_ptr, val);
36011 // debug statements here
36013 // 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, struct LDKChannelTypeFeatures channel_type_features_arg);
36015 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, channel_type_features_arg: bigint): bigint {
36016 if(!isWasmInitialized) {
36017 throw new Error("initializeWasm() must be awaited first!");
36019 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, channel_type_features_arg);
36020 return nativeResponseValue;
36022 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
36024 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
36025 if(!isWasmInitialized) {
36026 throw new Error("initializeWasm() must be awaited first!");
36028 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
36029 return nativeResponseValue;
36031 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
36033 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
36034 if(!isWasmInitialized) {
36035 throw new Error("initializeWasm() must be awaited first!");
36037 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
36038 return nativeResponseValue;
36040 // bool ChannelTransactionParameters_eq(const struct LDKChannelTransactionParameters *NONNULL_PTR a, const struct LDKChannelTransactionParameters *NONNULL_PTR b);
36042 export function ChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
36043 if(!isWasmInitialized) {
36044 throw new Error("initializeWasm() must be awaited first!");
36046 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_eq(a, b);
36047 return nativeResponseValue;
36049 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
36051 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
36052 if(!isWasmInitialized) {
36053 throw new Error("initializeWasm() must be awaited first!");
36055 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
36056 // debug statements here
36058 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
36060 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
36061 if(!isWasmInitialized) {
36062 throw new Error("initializeWasm() must be awaited first!");
36064 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
36065 return nativeResponseValue;
36067 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
36069 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
36070 if(!isWasmInitialized) {
36071 throw new Error("initializeWasm() must be awaited first!");
36073 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
36074 // debug statements here
36076 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
36078 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
36079 if(!isWasmInitialized) {
36080 throw new Error("initializeWasm() must be awaited first!");
36082 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
36083 return nativeResponseValue;
36085 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
36087 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
36088 if(!isWasmInitialized) {
36089 throw new Error("initializeWasm() must be awaited first!");
36091 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
36092 // debug statements here
36094 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
36096 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
36097 if(!isWasmInitialized) {
36098 throw new Error("initializeWasm() must be awaited first!");
36100 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
36101 return nativeResponseValue;
36103 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
36105 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
36106 if(!isWasmInitialized) {
36107 throw new Error("initializeWasm() must be awaited first!");
36109 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
36110 return nativeResponseValue;
36112 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
36114 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
36115 if(!isWasmInitialized) {
36116 throw new Error("initializeWasm() must be awaited first!");
36118 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
36119 return nativeResponseValue;
36121 // bool CounterpartyChannelTransactionParameters_eq(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR a, const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR b);
36123 export function CounterpartyChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
36124 if(!isWasmInitialized) {
36125 throw new Error("initializeWasm() must be awaited first!");
36127 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_eq(a, b);
36128 return nativeResponseValue;
36130 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
36132 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
36133 if(!isWasmInitialized) {
36134 throw new Error("initializeWasm() must be awaited first!");
36136 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
36137 return nativeResponseValue;
36139 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
36141 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
36142 if(!isWasmInitialized) {
36143 throw new Error("initializeWasm() must be awaited first!");
36145 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
36146 return nativeResponseValue;
36148 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
36150 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
36151 if(!isWasmInitialized) {
36152 throw new Error("initializeWasm() must be awaited first!");
36154 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
36155 return nativeResponseValue;
36157 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
36159 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
36160 if(!isWasmInitialized) {
36161 throw new Error("initializeWasm() must be awaited first!");
36163 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
36164 return nativeResponseValue;
36166 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
36168 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
36169 if(!isWasmInitialized) {
36170 throw new Error("initializeWasm() must be awaited first!");
36172 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
36173 return nativeResponseValue;
36175 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
36177 export function ChannelTransactionParameters_write(obj: bigint): number {
36178 if(!isWasmInitialized) {
36179 throw new Error("initializeWasm() must be awaited first!");
36181 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
36182 return nativeResponseValue;
36184 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
36186 export function ChannelTransactionParameters_read(ser: number): bigint {
36187 if(!isWasmInitialized) {
36188 throw new Error("initializeWasm() must be awaited first!");
36190 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
36191 return nativeResponseValue;
36193 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
36195 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
36196 if(!isWasmInitialized) {
36197 throw new Error("initializeWasm() must be awaited first!");
36199 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
36200 // debug statements here
36202 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
36204 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
36205 if(!isWasmInitialized) {
36206 throw new Error("initializeWasm() must be awaited first!");
36208 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
36209 return nativeResponseValue;
36211 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
36213 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
36214 if(!isWasmInitialized) {
36215 throw new Error("initializeWasm() must be awaited first!");
36217 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
36218 return nativeResponseValue;
36220 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
36222 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
36223 if(!isWasmInitialized) {
36224 throw new Error("initializeWasm() must be awaited first!");
36226 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
36227 return nativeResponseValue;
36229 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
36231 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
36232 if(!isWasmInitialized) {
36233 throw new Error("initializeWasm() must be awaited first!");
36235 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
36236 return nativeResponseValue;
36238 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
36240 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
36241 if(!isWasmInitialized) {
36242 throw new Error("initializeWasm() must be awaited first!");
36244 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
36245 return nativeResponseValue;
36247 // MUST_USE_RES struct LDKChannelTypeFeatures DirectedChannelTransactionParameters_channel_type_features(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
36249 export function DirectedChannelTransactionParameters_channel_type_features(this_arg: bigint): bigint {
36250 if(!isWasmInitialized) {
36251 throw new Error("initializeWasm() must be awaited first!");
36253 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_channel_type_features(this_arg);
36254 return nativeResponseValue;
36256 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
36258 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
36259 if(!isWasmInitialized) {
36260 throw new Error("initializeWasm() must be awaited first!");
36262 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
36263 // debug statements here
36265 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
36267 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
36268 if(!isWasmInitialized) {
36269 throw new Error("initializeWasm() must be awaited first!");
36271 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
36272 return nativeResponseValue;
36274 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
36276 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
36277 if(!isWasmInitialized) {
36278 throw new Error("initializeWasm() must be awaited first!");
36280 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
36281 // debug statements here
36283 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
36285 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
36286 if(!isWasmInitialized) {
36287 throw new Error("initializeWasm() must be awaited first!");
36289 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
36290 return nativeResponseValue;
36292 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
36294 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
36295 if(!isWasmInitialized) {
36296 throw new Error("initializeWasm() must be awaited first!");
36298 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
36299 // debug statements here
36301 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
36303 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
36304 if(!isWasmInitialized) {
36305 throw new Error("initializeWasm() must be awaited first!");
36307 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
36308 return nativeResponseValue;
36310 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
36312 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
36313 if(!isWasmInitialized) {
36314 throw new Error("initializeWasm() must be awaited first!");
36316 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
36317 return nativeResponseValue;
36319 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
36321 export function HolderCommitmentTransaction_write(obj: bigint): number {
36322 if(!isWasmInitialized) {
36323 throw new Error("initializeWasm() must be awaited first!");
36325 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
36326 return nativeResponseValue;
36328 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
36330 export function HolderCommitmentTransaction_read(ser: number): bigint {
36331 if(!isWasmInitialized) {
36332 throw new Error("initializeWasm() must be awaited first!");
36334 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
36335 return nativeResponseValue;
36337 // 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);
36339 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
36340 if(!isWasmInitialized) {
36341 throw new Error("initializeWasm() must be awaited first!");
36343 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
36344 return nativeResponseValue;
36346 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
36348 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
36349 if(!isWasmInitialized) {
36350 throw new Error("initializeWasm() must be awaited first!");
36352 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
36353 // debug statements here
36355 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
36357 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
36358 if(!isWasmInitialized) {
36359 throw new Error("initializeWasm() must be awaited first!");
36361 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
36362 return nativeResponseValue;
36364 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
36366 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
36367 if(!isWasmInitialized) {
36368 throw new Error("initializeWasm() must be awaited first!");
36370 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
36371 // debug statements here
36373 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
36375 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
36376 if(!isWasmInitialized) {
36377 throw new Error("initializeWasm() must be awaited first!");
36379 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
36380 return nativeResponseValue;
36382 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36384 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
36385 if(!isWasmInitialized) {
36386 throw new Error("initializeWasm() must be awaited first!");
36388 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
36389 // debug statements here
36391 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
36393 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
36394 if(!isWasmInitialized) {
36395 throw new Error("initializeWasm() must be awaited first!");
36397 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
36398 return nativeResponseValue;
36400 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
36402 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
36403 if(!isWasmInitialized) {
36404 throw new Error("initializeWasm() must be awaited first!");
36406 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
36407 return nativeResponseValue;
36409 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
36411 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
36412 if(!isWasmInitialized) {
36413 throw new Error("initializeWasm() must be awaited first!");
36415 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
36416 return nativeResponseValue;
36418 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
36420 export function BuiltCommitmentTransaction_write(obj: bigint): number {
36421 if(!isWasmInitialized) {
36422 throw new Error("initializeWasm() must be awaited first!");
36424 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
36425 return nativeResponseValue;
36427 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
36429 export function BuiltCommitmentTransaction_read(ser: number): bigint {
36430 if(!isWasmInitialized) {
36431 throw new Error("initializeWasm() must be awaited first!");
36433 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
36434 return nativeResponseValue;
36436 // 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);
36438 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
36439 if(!isWasmInitialized) {
36440 throw new Error("initializeWasm() must be awaited first!");
36442 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
36443 return nativeResponseValue;
36445 // MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign_counterparty_commitment(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
36447 export function BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
36448 if(!isWasmInitialized) {
36449 throw new Error("initializeWasm() must be awaited first!");
36451 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
36452 return nativeResponseValue;
36454 // MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign_holder_commitment(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis, const struct LDKEntropySource *NONNULL_PTR entropy_source);
36456 export function BuiltCommitmentTransaction_sign_holder_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint, entropy_source: bigint): number {
36457 if(!isWasmInitialized) {
36458 throw new Error("initializeWasm() must be awaited first!");
36460 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_holder_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis, entropy_source);
36461 return nativeResponseValue;
36463 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
36465 export function ClosingTransaction_free(this_obj: bigint): void {
36466 if(!isWasmInitialized) {
36467 throw new Error("initializeWasm() must be awaited first!");
36469 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
36470 // debug statements here
36472 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
36474 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
36475 if(!isWasmInitialized) {
36476 throw new Error("initializeWasm() must be awaited first!");
36478 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
36479 return nativeResponseValue;
36481 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
36483 export function ClosingTransaction_clone(orig: bigint): bigint {
36484 if(!isWasmInitialized) {
36485 throw new Error("initializeWasm() must be awaited first!");
36487 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
36488 return nativeResponseValue;
36490 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
36492 export function ClosingTransaction_hash(o: bigint): bigint {
36493 if(!isWasmInitialized) {
36494 throw new Error("initializeWasm() must be awaited first!");
36496 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
36497 return nativeResponseValue;
36499 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
36501 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
36502 if(!isWasmInitialized) {
36503 throw new Error("initializeWasm() must be awaited first!");
36505 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
36506 return nativeResponseValue;
36508 // 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);
36510 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 {
36511 if(!isWasmInitialized) {
36512 throw new Error("initializeWasm() must be awaited first!");
36514 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
36515 return nativeResponseValue;
36517 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
36519 export function ClosingTransaction_trust(this_arg: bigint): bigint {
36520 if(!isWasmInitialized) {
36521 throw new Error("initializeWasm() must be awaited first!");
36523 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
36524 return nativeResponseValue;
36526 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
36528 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
36529 if(!isWasmInitialized) {
36530 throw new Error("initializeWasm() must be awaited first!");
36532 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
36533 return nativeResponseValue;
36535 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
36537 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
36538 if(!isWasmInitialized) {
36539 throw new Error("initializeWasm() must be awaited first!");
36541 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
36542 return nativeResponseValue;
36544 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
36546 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
36547 if(!isWasmInitialized) {
36548 throw new Error("initializeWasm() must be awaited first!");
36550 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
36551 return nativeResponseValue;
36553 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
36555 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
36556 if(!isWasmInitialized) {
36557 throw new Error("initializeWasm() must be awaited first!");
36559 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
36560 return nativeResponseValue;
36562 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
36564 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
36565 if(!isWasmInitialized) {
36566 throw new Error("initializeWasm() must be awaited first!");
36568 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
36569 return nativeResponseValue;
36571 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
36573 export function TrustedClosingTransaction_free(this_obj: bigint): void {
36574 if(!isWasmInitialized) {
36575 throw new Error("initializeWasm() must be awaited first!");
36577 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
36578 // debug statements here
36580 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
36582 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
36583 if(!isWasmInitialized) {
36584 throw new Error("initializeWasm() must be awaited first!");
36586 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
36587 return nativeResponseValue;
36589 // 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);
36591 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
36592 if(!isWasmInitialized) {
36593 throw new Error("initializeWasm() must be awaited first!");
36595 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
36596 return nativeResponseValue;
36598 // 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);
36600 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
36601 if(!isWasmInitialized) {
36602 throw new Error("initializeWasm() must be awaited first!");
36604 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
36605 return nativeResponseValue;
36607 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
36609 export function CommitmentTransaction_free(this_obj: bigint): void {
36610 if(!isWasmInitialized) {
36611 throw new Error("initializeWasm() must be awaited first!");
36613 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
36614 // debug statements here
36616 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
36618 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
36619 if(!isWasmInitialized) {
36620 throw new Error("initializeWasm() must be awaited first!");
36622 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
36623 return nativeResponseValue;
36625 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
36627 export function CommitmentTransaction_clone(orig: bigint): bigint {
36628 if(!isWasmInitialized) {
36629 throw new Error("initializeWasm() must be awaited first!");
36631 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
36632 return nativeResponseValue;
36634 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
36636 export function CommitmentTransaction_write(obj: bigint): number {
36637 if(!isWasmInitialized) {
36638 throw new Error("initializeWasm() must be awaited first!");
36640 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
36641 return nativeResponseValue;
36643 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
36645 export function CommitmentTransaction_read(ser: number): bigint {
36646 if(!isWasmInitialized) {
36647 throw new Error("initializeWasm() must be awaited first!");
36649 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
36650 return nativeResponseValue;
36652 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
36654 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
36655 if(!isWasmInitialized) {
36656 throw new Error("initializeWasm() must be awaited first!");
36658 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
36659 return nativeResponseValue;
36661 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
36663 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
36664 if(!isWasmInitialized) {
36665 throw new Error("initializeWasm() must be awaited first!");
36667 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
36668 return nativeResponseValue;
36670 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
36672 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
36673 if(!isWasmInitialized) {
36674 throw new Error("initializeWasm() must be awaited first!");
36676 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
36677 return nativeResponseValue;
36679 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
36681 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
36682 if(!isWasmInitialized) {
36683 throw new Error("initializeWasm() must be awaited first!");
36685 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
36686 return nativeResponseValue;
36688 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
36690 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
36691 if(!isWasmInitialized) {
36692 throw new Error("initializeWasm() must be awaited first!");
36694 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
36695 return nativeResponseValue;
36697 // 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);
36699 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
36700 if(!isWasmInitialized) {
36701 throw new Error("initializeWasm() must be awaited first!");
36703 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
36704 return nativeResponseValue;
36706 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
36708 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
36709 if(!isWasmInitialized) {
36710 throw new Error("initializeWasm() must be awaited first!");
36712 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
36713 // debug statements here
36715 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
36717 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
36718 if(!isWasmInitialized) {
36719 throw new Error("initializeWasm() must be awaited first!");
36721 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
36722 return nativeResponseValue;
36724 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
36726 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
36727 if(!isWasmInitialized) {
36728 throw new Error("initializeWasm() must be awaited first!");
36730 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
36731 return nativeResponseValue;
36733 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
36735 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
36736 if(!isWasmInitialized) {
36737 throw new Error("initializeWasm() must be awaited first!");
36739 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
36740 return nativeResponseValue;
36742 // MUST_USE_RES struct LDKChannelTypeFeatures TrustedCommitmentTransaction_channel_type_features(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
36744 export function TrustedCommitmentTransaction_channel_type_features(this_arg: bigint): bigint {
36745 if(!isWasmInitialized) {
36746 throw new Error("initializeWasm() must be awaited first!");
36748 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_channel_type_features(this_arg);
36749 return nativeResponseValue;
36751 // 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, const struct LDKEntropySource *NONNULL_PTR entropy_source);
36753 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint, entropy_source: bigint): bigint {
36754 if(!isWasmInitialized) {
36755 throw new Error("initializeWasm() must be awaited first!");
36757 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters, entropy_source);
36758 return nativeResponseValue;
36760 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
36762 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
36763 if(!isWasmInitialized) {
36764 throw new Error("initializeWasm() must be awaited first!");
36766 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
36767 return nativeResponseValue;
36769 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
36771 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
36772 if(!isWasmInitialized) {
36773 throw new Error("initializeWasm() must be awaited first!");
36775 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
36776 return nativeResponseValue;
36778 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
36780 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
36781 if(!isWasmInitialized) {
36782 throw new Error("initializeWasm() must be awaited first!");
36784 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
36785 return nativeResponseValue;
36787 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
36789 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
36790 if(!isWasmInitialized) {
36791 throw new Error("initializeWasm() must be awaited first!");
36793 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
36794 return nativeResponseValue;
36796 // bool Bolt11InvoiceFeatures_eq(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR b);
36798 export function Bolt11InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
36799 if(!isWasmInitialized) {
36800 throw new Error("initializeWasm() must be awaited first!");
36802 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_eq(a, b);
36803 return nativeResponseValue;
36805 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
36807 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
36808 if(!isWasmInitialized) {
36809 throw new Error("initializeWasm() must be awaited first!");
36811 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
36812 return nativeResponseValue;
36814 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
36816 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
36817 if(!isWasmInitialized) {
36818 throw new Error("initializeWasm() must be awaited first!");
36820 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
36821 return nativeResponseValue;
36823 // bool Bolt12InvoiceFeatures_eq(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR b);
36825 export function Bolt12InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
36826 if(!isWasmInitialized) {
36827 throw new Error("initializeWasm() must be awaited first!");
36829 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_eq(a, b);
36830 return nativeResponseValue;
36832 // bool BlindedHopFeatures_eq(const struct LDKBlindedHopFeatures *NONNULL_PTR a, const struct LDKBlindedHopFeatures *NONNULL_PTR b);
36834 export function BlindedHopFeatures_eq(a: bigint, b: bigint): boolean {
36835 if(!isWasmInitialized) {
36836 throw new Error("initializeWasm() must be awaited first!");
36838 const nativeResponseValue = wasm.TS_BlindedHopFeatures_eq(a, b);
36839 return nativeResponseValue;
36841 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
36843 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
36844 if(!isWasmInitialized) {
36845 throw new Error("initializeWasm() must be awaited first!");
36847 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
36848 return nativeResponseValue;
36850 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
36852 export function InitFeatures_clone_ptr(arg: bigint): bigint {
36853 if(!isWasmInitialized) {
36854 throw new Error("initializeWasm() must be awaited first!");
36856 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
36857 return nativeResponseValue;
36859 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
36861 export function InitFeatures_clone(orig: bigint): bigint {
36862 if(!isWasmInitialized) {
36863 throw new Error("initializeWasm() must be awaited first!");
36865 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
36866 return nativeResponseValue;
36868 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
36870 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
36871 if(!isWasmInitialized) {
36872 throw new Error("initializeWasm() must be awaited first!");
36874 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
36875 return nativeResponseValue;
36877 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
36879 export function NodeFeatures_clone(orig: bigint): bigint {
36880 if(!isWasmInitialized) {
36881 throw new Error("initializeWasm() must be awaited first!");
36883 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
36884 return nativeResponseValue;
36886 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
36888 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
36889 if(!isWasmInitialized) {
36890 throw new Error("initializeWasm() must be awaited first!");
36892 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
36893 return nativeResponseValue;
36895 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
36897 export function ChannelFeatures_clone(orig: bigint): bigint {
36898 if(!isWasmInitialized) {
36899 throw new Error("initializeWasm() must be awaited first!");
36901 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
36902 return nativeResponseValue;
36904 // uint64_t Bolt11InvoiceFeatures_clone_ptr(LDKBolt11InvoiceFeatures *NONNULL_PTR arg);
36906 export function Bolt11InvoiceFeatures_clone_ptr(arg: bigint): bigint {
36907 if(!isWasmInitialized) {
36908 throw new Error("initializeWasm() must be awaited first!");
36910 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone_ptr(arg);
36911 return nativeResponseValue;
36913 // struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_clone(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR orig);
36915 export function Bolt11InvoiceFeatures_clone(orig: bigint): bigint {
36916 if(!isWasmInitialized) {
36917 throw new Error("initializeWasm() must be awaited first!");
36919 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone(orig);
36920 return nativeResponseValue;
36922 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
36924 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
36925 if(!isWasmInitialized) {
36926 throw new Error("initializeWasm() must be awaited first!");
36928 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
36929 return nativeResponseValue;
36931 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
36933 export function OfferFeatures_clone(orig: bigint): bigint {
36934 if(!isWasmInitialized) {
36935 throw new Error("initializeWasm() must be awaited first!");
36937 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
36938 return nativeResponseValue;
36940 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
36942 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
36943 if(!isWasmInitialized) {
36944 throw new Error("initializeWasm() must be awaited first!");
36946 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
36947 return nativeResponseValue;
36949 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
36951 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
36952 if(!isWasmInitialized) {
36953 throw new Error("initializeWasm() must be awaited first!");
36955 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
36956 return nativeResponseValue;
36958 // uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg);
36960 export function Bolt12InvoiceFeatures_clone_ptr(arg: bigint): bigint {
36961 if(!isWasmInitialized) {
36962 throw new Error("initializeWasm() must be awaited first!");
36964 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone_ptr(arg);
36965 return nativeResponseValue;
36967 // struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_clone(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR orig);
36969 export function Bolt12InvoiceFeatures_clone(orig: bigint): bigint {
36970 if(!isWasmInitialized) {
36971 throw new Error("initializeWasm() must be awaited first!");
36973 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone(orig);
36974 return nativeResponseValue;
36976 // uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg);
36978 export function BlindedHopFeatures_clone_ptr(arg: bigint): bigint {
36979 if(!isWasmInitialized) {
36980 throw new Error("initializeWasm() must be awaited first!");
36982 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone_ptr(arg);
36983 return nativeResponseValue;
36985 // struct LDKBlindedHopFeatures BlindedHopFeatures_clone(const struct LDKBlindedHopFeatures *NONNULL_PTR orig);
36987 export function BlindedHopFeatures_clone(orig: bigint): bigint {
36988 if(!isWasmInitialized) {
36989 throw new Error("initializeWasm() must be awaited first!");
36991 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone(orig);
36992 return nativeResponseValue;
36994 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
36996 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
36997 if(!isWasmInitialized) {
36998 throw new Error("initializeWasm() must be awaited first!");
37000 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
37001 return nativeResponseValue;
37003 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
37005 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
37006 if(!isWasmInitialized) {
37007 throw new Error("initializeWasm() must be awaited first!");
37009 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
37010 return nativeResponseValue;
37012 // void InitFeatures_free(struct LDKInitFeatures this_obj);
37014 export function InitFeatures_free(this_obj: bigint): void {
37015 if(!isWasmInitialized) {
37016 throw new Error("initializeWasm() must be awaited first!");
37018 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
37019 // debug statements here
37021 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
37023 export function NodeFeatures_free(this_obj: bigint): void {
37024 if(!isWasmInitialized) {
37025 throw new Error("initializeWasm() must be awaited first!");
37027 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
37028 // debug statements here
37030 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
37032 export function ChannelFeatures_free(this_obj: bigint): void {
37033 if(!isWasmInitialized) {
37034 throw new Error("initializeWasm() must be awaited first!");
37036 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
37037 // debug statements here
37039 // void Bolt11InvoiceFeatures_free(struct LDKBolt11InvoiceFeatures this_obj);
37041 export function Bolt11InvoiceFeatures_free(this_obj: bigint): void {
37042 if(!isWasmInitialized) {
37043 throw new Error("initializeWasm() must be awaited first!");
37045 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_free(this_obj);
37046 // debug statements here
37048 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
37050 export function OfferFeatures_free(this_obj: bigint): void {
37051 if(!isWasmInitialized) {
37052 throw new Error("initializeWasm() must be awaited first!");
37054 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
37055 // debug statements here
37057 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
37059 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
37060 if(!isWasmInitialized) {
37061 throw new Error("initializeWasm() must be awaited first!");
37063 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
37064 // debug statements here
37066 // void Bolt12InvoiceFeatures_free(struct LDKBolt12InvoiceFeatures this_obj);
37068 export function Bolt12InvoiceFeatures_free(this_obj: bigint): void {
37069 if(!isWasmInitialized) {
37070 throw new Error("initializeWasm() must be awaited first!");
37072 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_free(this_obj);
37073 // debug statements here
37075 // void BlindedHopFeatures_free(struct LDKBlindedHopFeatures this_obj);
37077 export function BlindedHopFeatures_free(this_obj: bigint): void {
37078 if(!isWasmInitialized) {
37079 throw new Error("initializeWasm() must be awaited first!");
37081 const nativeResponseValue = wasm.TS_BlindedHopFeatures_free(this_obj);
37082 // debug statements here
37084 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
37086 export function ChannelTypeFeatures_free(this_obj: bigint): void {
37087 if(!isWasmInitialized) {
37088 throw new Error("initializeWasm() must be awaited first!");
37090 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
37091 // debug statements here
37093 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
37095 export function InitFeatures_empty(): bigint {
37096 if(!isWasmInitialized) {
37097 throw new Error("initializeWasm() must be awaited first!");
37099 const nativeResponseValue = wasm.TS_InitFeatures_empty();
37100 return nativeResponseValue;
37102 // MUST_USE_RES bool InitFeatures_requires_unknown_bits_from(const struct LDKInitFeatures *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR other);
37104 export function InitFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37105 if(!isWasmInitialized) {
37106 throw new Error("initializeWasm() must be awaited first!");
37108 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits_from(this_arg, other);
37109 return nativeResponseValue;
37111 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37113 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37114 if(!isWasmInitialized) {
37115 throw new Error("initializeWasm() must be awaited first!");
37117 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
37118 return nativeResponseValue;
37120 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37122 export function InitFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37123 if(!isWasmInitialized) {
37124 throw new Error("initializeWasm() must be awaited first!");
37126 const nativeResponseValue = wasm.TS_InitFeatures_set_required_custom_bit(this_arg, bit);
37127 return nativeResponseValue;
37129 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37131 export function InitFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37132 if(!isWasmInitialized) {
37133 throw new Error("initializeWasm() must be awaited first!");
37135 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_custom_bit(this_arg, bit);
37136 return nativeResponseValue;
37138 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
37140 export function NodeFeatures_empty(): bigint {
37141 if(!isWasmInitialized) {
37142 throw new Error("initializeWasm() must be awaited first!");
37144 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
37145 return nativeResponseValue;
37147 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits_from(const struct LDKNodeFeatures *NONNULL_PTR this_arg, const struct LDKNodeFeatures *NONNULL_PTR other);
37149 export function NodeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37150 if(!isWasmInitialized) {
37151 throw new Error("initializeWasm() must be awaited first!");
37153 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits_from(this_arg, other);
37154 return nativeResponseValue;
37156 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37158 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37159 if(!isWasmInitialized) {
37160 throw new Error("initializeWasm() must be awaited first!");
37162 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
37163 return nativeResponseValue;
37165 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37167 export function NodeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37168 if(!isWasmInitialized) {
37169 throw new Error("initializeWasm() must be awaited first!");
37171 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_custom_bit(this_arg, bit);
37172 return nativeResponseValue;
37174 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37176 export function NodeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37177 if(!isWasmInitialized) {
37178 throw new Error("initializeWasm() must be awaited first!");
37180 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_custom_bit(this_arg, bit);
37181 return nativeResponseValue;
37183 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
37185 export function ChannelFeatures_empty(): bigint {
37186 if(!isWasmInitialized) {
37187 throw new Error("initializeWasm() must be awaited first!");
37189 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
37190 return nativeResponseValue;
37192 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits_from(const struct LDKChannelFeatures *NONNULL_PTR this_arg, const struct LDKChannelFeatures *NONNULL_PTR other);
37194 export function ChannelFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37195 if(!isWasmInitialized) {
37196 throw new Error("initializeWasm() must be awaited first!");
37198 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits_from(this_arg, other);
37199 return nativeResponseValue;
37201 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
37203 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37204 if(!isWasmInitialized) {
37205 throw new Error("initializeWasm() must be awaited first!");
37207 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
37208 return nativeResponseValue;
37210 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37212 export function ChannelFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37213 if(!isWasmInitialized) {
37214 throw new Error("initializeWasm() must be awaited first!");
37216 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_custom_bit(this_arg, bit);
37217 return nativeResponseValue;
37219 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37221 export function ChannelFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37222 if(!isWasmInitialized) {
37223 throw new Error("initializeWasm() must be awaited first!");
37225 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_custom_bit(this_arg, bit);
37226 return nativeResponseValue;
37228 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_empty(void);
37230 export function Bolt11InvoiceFeatures_empty(): bigint {
37231 if(!isWasmInitialized) {
37232 throw new Error("initializeWasm() must be awaited first!");
37234 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_empty();
37235 return nativeResponseValue;
37237 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR other);
37239 export function Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37240 if(!isWasmInitialized) {
37241 throw new Error("initializeWasm() must be awaited first!");
37243 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
37244 return nativeResponseValue;
37246 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
37248 export function Bolt11InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37249 if(!isWasmInitialized) {
37250 throw new Error("initializeWasm() must be awaited first!");
37252 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits(this_arg);
37253 return nativeResponseValue;
37255 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37257 export function Bolt11InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37258 if(!isWasmInitialized) {
37259 throw new Error("initializeWasm() must be awaited first!");
37261 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_custom_bit(this_arg, bit);
37262 return nativeResponseValue;
37264 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37266 export function Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37267 if(!isWasmInitialized) {
37268 throw new Error("initializeWasm() must be awaited first!");
37270 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
37271 return nativeResponseValue;
37273 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
37275 export function OfferFeatures_empty(): bigint {
37276 if(!isWasmInitialized) {
37277 throw new Error("initializeWasm() must be awaited first!");
37279 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
37280 return nativeResponseValue;
37282 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits_from(const struct LDKOfferFeatures *NONNULL_PTR this_arg, const struct LDKOfferFeatures *NONNULL_PTR other);
37284 export function OfferFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37285 if(!isWasmInitialized) {
37286 throw new Error("initializeWasm() must be awaited first!");
37288 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits_from(this_arg, other);
37289 return nativeResponseValue;
37291 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
37293 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37294 if(!isWasmInitialized) {
37295 throw new Error("initializeWasm() must be awaited first!");
37297 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
37298 return nativeResponseValue;
37300 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37302 export function OfferFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37303 if(!isWasmInitialized) {
37304 throw new Error("initializeWasm() must be awaited first!");
37306 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_custom_bit(this_arg, bit);
37307 return nativeResponseValue;
37309 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37311 export function OfferFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37312 if(!isWasmInitialized) {
37313 throw new Error("initializeWasm() must be awaited first!");
37315 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_custom_bit(this_arg, bit);
37316 return nativeResponseValue;
37318 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
37320 export function InvoiceRequestFeatures_empty(): bigint {
37321 if(!isWasmInitialized) {
37322 throw new Error("initializeWasm() must be awaited first!");
37324 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
37325 return nativeResponseValue;
37327 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits_from(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, const struct LDKInvoiceRequestFeatures *NONNULL_PTR other);
37329 export function InvoiceRequestFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37330 if(!isWasmInitialized) {
37331 throw new Error("initializeWasm() must be awaited first!");
37333 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits_from(this_arg, other);
37334 return nativeResponseValue;
37336 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
37338 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37339 if(!isWasmInitialized) {
37340 throw new Error("initializeWasm() must be awaited first!");
37342 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
37343 return nativeResponseValue;
37345 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37347 export function InvoiceRequestFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37348 if(!isWasmInitialized) {
37349 throw new Error("initializeWasm() must be awaited first!");
37351 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_custom_bit(this_arg, bit);
37352 return nativeResponseValue;
37354 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37356 export function InvoiceRequestFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37357 if(!isWasmInitialized) {
37358 throw new Error("initializeWasm() must be awaited first!");
37360 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_custom_bit(this_arg, bit);
37361 return nativeResponseValue;
37363 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_empty(void);
37365 export function Bolt12InvoiceFeatures_empty(): bigint {
37366 if(!isWasmInitialized) {
37367 throw new Error("initializeWasm() must be awaited first!");
37369 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_empty();
37370 return nativeResponseValue;
37372 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR other);
37374 export function Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37375 if(!isWasmInitialized) {
37376 throw new Error("initializeWasm() must be awaited first!");
37378 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
37379 return nativeResponseValue;
37381 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
37383 export function Bolt12InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37384 if(!isWasmInitialized) {
37385 throw new Error("initializeWasm() must be awaited first!");
37387 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits(this_arg);
37388 return nativeResponseValue;
37390 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37392 export function Bolt12InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37393 if(!isWasmInitialized) {
37394 throw new Error("initializeWasm() must be awaited first!");
37396 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_custom_bit(this_arg, bit);
37397 return nativeResponseValue;
37399 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37401 export function Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37402 if(!isWasmInitialized) {
37403 throw new Error("initializeWasm() must be awaited first!");
37405 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
37406 return nativeResponseValue;
37408 // MUST_USE_RES struct LDKBlindedHopFeatures BlindedHopFeatures_empty(void);
37410 export function BlindedHopFeatures_empty(): bigint {
37411 if(!isWasmInitialized) {
37412 throw new Error("initializeWasm() must be awaited first!");
37414 const nativeResponseValue = wasm.TS_BlindedHopFeatures_empty();
37415 return nativeResponseValue;
37417 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits_from(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, const struct LDKBlindedHopFeatures *NONNULL_PTR other);
37419 export function BlindedHopFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37420 if(!isWasmInitialized) {
37421 throw new Error("initializeWasm() must be awaited first!");
37423 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits_from(this_arg, other);
37424 return nativeResponseValue;
37426 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg);
37428 export function BlindedHopFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37429 if(!isWasmInitialized) {
37430 throw new Error("initializeWasm() must be awaited first!");
37432 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits(this_arg);
37433 return nativeResponseValue;
37435 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37437 export function BlindedHopFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37438 if(!isWasmInitialized) {
37439 throw new Error("initializeWasm() must be awaited first!");
37441 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_custom_bit(this_arg, bit);
37442 return nativeResponseValue;
37444 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37446 export function BlindedHopFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37447 if(!isWasmInitialized) {
37448 throw new Error("initializeWasm() must be awaited first!");
37450 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_custom_bit(this_arg, bit);
37451 return nativeResponseValue;
37453 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
37455 export function ChannelTypeFeatures_empty(): bigint {
37456 if(!isWasmInitialized) {
37457 throw new Error("initializeWasm() must be awaited first!");
37459 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
37460 return nativeResponseValue;
37462 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits_from(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, const struct LDKChannelTypeFeatures *NONNULL_PTR other);
37464 export function ChannelTypeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
37465 if(!isWasmInitialized) {
37466 throw new Error("initializeWasm() must be awaited first!");
37468 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits_from(this_arg, other);
37469 return nativeResponseValue;
37471 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
37473 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
37474 if(!isWasmInitialized) {
37475 throw new Error("initializeWasm() must be awaited first!");
37477 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
37478 return nativeResponseValue;
37480 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37482 export function ChannelTypeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
37483 if(!isWasmInitialized) {
37484 throw new Error("initializeWasm() must be awaited first!");
37486 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_custom_bit(this_arg, bit);
37487 return nativeResponseValue;
37489 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
37491 export function ChannelTypeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
37492 if(!isWasmInitialized) {
37493 throw new Error("initializeWasm() must be awaited first!");
37495 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_custom_bit(this_arg, bit);
37496 return nativeResponseValue;
37498 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
37500 export function InitFeatures_write(obj: bigint): number {
37501 if(!isWasmInitialized) {
37502 throw new Error("initializeWasm() must be awaited first!");
37504 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
37505 return nativeResponseValue;
37507 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
37509 export function InitFeatures_read(ser: number): bigint {
37510 if(!isWasmInitialized) {
37511 throw new Error("initializeWasm() must be awaited first!");
37513 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
37514 return nativeResponseValue;
37516 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
37518 export function ChannelFeatures_write(obj: bigint): number {
37519 if(!isWasmInitialized) {
37520 throw new Error("initializeWasm() must be awaited first!");
37522 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
37523 return nativeResponseValue;
37525 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
37527 export function ChannelFeatures_read(ser: number): bigint {
37528 if(!isWasmInitialized) {
37529 throw new Error("initializeWasm() must be awaited first!");
37531 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
37532 return nativeResponseValue;
37534 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
37536 export function NodeFeatures_write(obj: bigint): number {
37537 if(!isWasmInitialized) {
37538 throw new Error("initializeWasm() must be awaited first!");
37540 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
37541 return nativeResponseValue;
37543 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
37545 export function NodeFeatures_read(ser: number): bigint {
37546 if(!isWasmInitialized) {
37547 throw new Error("initializeWasm() must be awaited first!");
37549 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
37550 return nativeResponseValue;
37552 // struct LDKCVec_u8Z Bolt11InvoiceFeatures_write(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR obj);
37554 export function Bolt11InvoiceFeatures_write(obj: bigint): number {
37555 if(!isWasmInitialized) {
37556 throw new Error("initializeWasm() must be awaited first!");
37558 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_write(obj);
37559 return nativeResponseValue;
37561 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ Bolt11InvoiceFeatures_read(struct LDKu8slice ser);
37563 export function Bolt11InvoiceFeatures_read(ser: number): bigint {
37564 if(!isWasmInitialized) {
37565 throw new Error("initializeWasm() must be awaited first!");
37567 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_read(ser);
37568 return nativeResponseValue;
37570 // struct LDKCVec_u8Z Bolt12InvoiceFeatures_write(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR obj);
37572 export function Bolt12InvoiceFeatures_write(obj: bigint): number {
37573 if(!isWasmInitialized) {
37574 throw new Error("initializeWasm() must be awaited first!");
37576 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_write(obj);
37577 return nativeResponseValue;
37579 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ Bolt12InvoiceFeatures_read(struct LDKu8slice ser);
37581 export function Bolt12InvoiceFeatures_read(ser: number): bigint {
37582 if(!isWasmInitialized) {
37583 throw new Error("initializeWasm() must be awaited first!");
37585 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_read(ser);
37586 return nativeResponseValue;
37588 // struct LDKCVec_u8Z BlindedHopFeatures_write(const struct LDKBlindedHopFeatures *NONNULL_PTR obj);
37590 export function BlindedHopFeatures_write(obj: bigint): number {
37591 if(!isWasmInitialized) {
37592 throw new Error("initializeWasm() must be awaited first!");
37594 const nativeResponseValue = wasm.TS_BlindedHopFeatures_write(obj);
37595 return nativeResponseValue;
37597 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ BlindedHopFeatures_read(struct LDKu8slice ser);
37599 export function BlindedHopFeatures_read(ser: number): bigint {
37600 if(!isWasmInitialized) {
37601 throw new Error("initializeWasm() must be awaited first!");
37603 const nativeResponseValue = wasm.TS_BlindedHopFeatures_read(ser);
37604 return nativeResponseValue;
37606 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
37608 export function ChannelTypeFeatures_write(obj: bigint): number {
37609 if(!isWasmInitialized) {
37610 throw new Error("initializeWasm() must be awaited first!");
37612 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
37613 return nativeResponseValue;
37615 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
37617 export function ChannelTypeFeatures_read(ser: number): bigint {
37618 if(!isWasmInitialized) {
37619 throw new Error("initializeWasm() must be awaited first!");
37621 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
37622 return nativeResponseValue;
37624 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
37626 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
37627 if(!isWasmInitialized) {
37628 throw new Error("initializeWasm() must be awaited first!");
37630 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
37631 // debug statements here
37633 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
37635 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
37636 if(!isWasmInitialized) {
37637 throw new Error("initializeWasm() must be awaited first!");
37639 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
37640 // debug statements here
37642 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37644 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
37645 if(!isWasmInitialized) {
37646 throw new Error("initializeWasm() must be awaited first!");
37648 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
37649 return nativeResponseValue;
37651 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37653 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
37654 if(!isWasmInitialized) {
37655 throw new Error("initializeWasm() must be awaited first!");
37657 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
37658 // debug statements here
37660 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37662 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
37663 if(!isWasmInitialized) {
37664 throw new Error("initializeWasm() must be awaited first!");
37666 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
37667 // debug statements here
37669 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37671 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
37672 if(!isWasmInitialized) {
37673 throw new Error("initializeWasm() must be awaited first!");
37675 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
37676 return nativeResponseValue;
37678 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37680 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
37681 if(!isWasmInitialized) {
37682 throw new Error("initializeWasm() must be awaited first!");
37684 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
37685 return nativeResponseValue;
37687 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37689 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
37690 if(!isWasmInitialized) {
37691 throw new Error("initializeWasm() must be awaited first!");
37693 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
37694 return nativeResponseValue;
37696 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
37698 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
37699 if(!isWasmInitialized) {
37700 throw new Error("initializeWasm() must be awaited first!");
37702 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
37703 // debug statements here
37705 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
37707 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
37708 if(!isWasmInitialized) {
37709 throw new Error("initializeWasm() must be awaited first!");
37711 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
37712 // debug statements here
37714 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37716 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
37717 if(!isWasmInitialized) {
37718 throw new Error("initializeWasm() must be awaited first!");
37720 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
37721 return nativeResponseValue;
37723 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
37725 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
37726 if(!isWasmInitialized) {
37727 throw new Error("initializeWasm() must be awaited first!");
37729 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
37730 // debug statements here
37732 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
37734 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
37735 if(!isWasmInitialized) {
37736 throw new Error("initializeWasm() must be awaited first!");
37738 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
37739 // debug statements here
37741 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37743 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
37744 if(!isWasmInitialized) {
37745 throw new Error("initializeWasm() must be awaited first!");
37747 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
37748 return nativeResponseValue;
37750 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37752 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
37753 if(!isWasmInitialized) {
37754 throw new Error("initializeWasm() must be awaited first!");
37756 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
37757 // debug statements here
37759 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37761 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
37762 if(!isWasmInitialized) {
37763 throw new Error("initializeWasm() must be awaited first!");
37765 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
37766 // debug statements here
37768 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37770 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
37771 if(!isWasmInitialized) {
37772 throw new Error("initializeWasm() must be awaited first!");
37774 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
37775 return nativeResponseValue;
37777 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37779 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
37780 if(!isWasmInitialized) {
37781 throw new Error("initializeWasm() must be awaited first!");
37783 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
37784 return nativeResponseValue;
37786 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37788 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
37789 if(!isWasmInitialized) {
37790 throw new Error("initializeWasm() must be awaited first!");
37792 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
37793 return nativeResponseValue;
37795 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
37797 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
37798 if(!isWasmInitialized) {
37799 throw new Error("initializeWasm() must be awaited first!");
37801 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
37802 // debug statements here
37804 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
37806 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
37807 if(!isWasmInitialized) {
37808 throw new Error("initializeWasm() must be awaited first!");
37810 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
37811 // debug statements here
37813 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37815 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
37816 if(!isWasmInitialized) {
37817 throw new Error("initializeWasm() must be awaited first!");
37819 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
37820 return nativeResponseValue;
37822 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37824 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
37825 if(!isWasmInitialized) {
37826 throw new Error("initializeWasm() must be awaited first!");
37828 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
37829 // debug statements here
37831 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37833 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
37834 if(!isWasmInitialized) {
37835 throw new Error("initializeWasm() must be awaited first!");
37837 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
37838 // debug statements here
37840 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37842 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
37843 if(!isWasmInitialized) {
37844 throw new Error("initializeWasm() must be awaited first!");
37846 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
37847 return nativeResponseValue;
37849 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37851 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
37852 if(!isWasmInitialized) {
37853 throw new Error("initializeWasm() must be awaited first!");
37855 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
37856 return nativeResponseValue;
37858 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37860 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
37861 if(!isWasmInitialized) {
37862 throw new Error("initializeWasm() must be awaited first!");
37864 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
37865 return nativeResponseValue;
37867 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
37869 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
37870 if(!isWasmInitialized) {
37871 throw new Error("initializeWasm() must be awaited first!");
37873 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
37874 // debug statements here
37876 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
37878 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
37879 if(!isWasmInitialized) {
37880 throw new Error("initializeWasm() must be awaited first!");
37882 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
37883 // debug statements here
37885 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37887 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
37888 if(!isWasmInitialized) {
37889 throw new Error("initializeWasm() must be awaited first!");
37891 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
37892 return nativeResponseValue;
37894 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37896 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
37897 if(!isWasmInitialized) {
37898 throw new Error("initializeWasm() must be awaited first!");
37900 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
37901 // debug statements here
37903 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
37905 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
37906 if(!isWasmInitialized) {
37907 throw new Error("initializeWasm() must be awaited first!");
37909 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
37910 // debug statements here
37912 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37914 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
37915 if(!isWasmInitialized) {
37916 throw new Error("initializeWasm() must be awaited first!");
37918 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
37919 return nativeResponseValue;
37921 // void Bolt11InvoiceFeatures_set_variable_length_onion_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
37923 export function Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
37924 if(!isWasmInitialized) {
37925 throw new Error("initializeWasm() must be awaited first!");
37927 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg);
37928 // debug statements here
37930 // void Bolt11InvoiceFeatures_set_variable_length_onion_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
37932 export function Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
37933 if(!isWasmInitialized) {
37934 throw new Error("initializeWasm() must be awaited first!");
37936 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg);
37937 // debug statements here
37939 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
37941 export function Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
37942 if(!isWasmInitialized) {
37943 throw new Error("initializeWasm() must be awaited first!");
37945 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg);
37946 return nativeResponseValue;
37948 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37950 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
37951 if(!isWasmInitialized) {
37952 throw new Error("initializeWasm() must be awaited first!");
37954 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
37955 return nativeResponseValue;
37957 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
37959 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
37960 if(!isWasmInitialized) {
37961 throw new Error("initializeWasm() must be awaited first!");
37963 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
37964 return nativeResponseValue;
37966 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
37968 export function Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
37969 if(!isWasmInitialized) {
37970 throw new Error("initializeWasm() must be awaited first!");
37972 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg);
37973 return nativeResponseValue;
37975 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
37977 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
37978 if(!isWasmInitialized) {
37979 throw new Error("initializeWasm() must be awaited first!");
37981 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
37982 // debug statements here
37984 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
37986 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
37987 if(!isWasmInitialized) {
37988 throw new Error("initializeWasm() must be awaited first!");
37990 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
37991 // debug statements here
37993 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
37995 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
37996 if(!isWasmInitialized) {
37997 throw new Error("initializeWasm() must be awaited first!");
37999 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
38000 return nativeResponseValue;
38002 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38004 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
38005 if(!isWasmInitialized) {
38006 throw new Error("initializeWasm() must be awaited first!");
38008 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
38009 // debug statements here
38011 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38013 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
38014 if(!isWasmInitialized) {
38015 throw new Error("initializeWasm() must be awaited first!");
38017 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
38018 // debug statements here
38020 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38022 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
38023 if(!isWasmInitialized) {
38024 throw new Error("initializeWasm() must be awaited first!");
38026 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
38027 return nativeResponseValue;
38029 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38031 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
38032 if(!isWasmInitialized) {
38033 throw new Error("initializeWasm() must be awaited first!");
38035 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
38036 // debug statements here
38038 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38040 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
38041 if(!isWasmInitialized) {
38042 throw new Error("initializeWasm() must be awaited first!");
38044 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
38045 // debug statements here
38047 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38049 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
38050 if(!isWasmInitialized) {
38051 throw new Error("initializeWasm() must be awaited first!");
38053 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
38054 return nativeResponseValue;
38056 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38058 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
38059 if(!isWasmInitialized) {
38060 throw new Error("initializeWasm() must be awaited first!");
38062 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
38063 return nativeResponseValue;
38065 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38067 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
38068 if(!isWasmInitialized) {
38069 throw new Error("initializeWasm() must be awaited first!");
38071 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
38072 return nativeResponseValue;
38074 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38076 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
38077 if(!isWasmInitialized) {
38078 throw new Error("initializeWasm() must be awaited first!");
38080 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
38081 return nativeResponseValue;
38083 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38085 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
38086 if(!isWasmInitialized) {
38087 throw new Error("initializeWasm() must be awaited first!");
38089 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
38090 // debug statements here
38092 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38094 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
38095 if(!isWasmInitialized) {
38096 throw new Error("initializeWasm() must be awaited first!");
38098 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
38099 // debug statements here
38101 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38103 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
38104 if(!isWasmInitialized) {
38105 throw new Error("initializeWasm() must be awaited first!");
38107 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
38108 return nativeResponseValue;
38110 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38112 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
38113 if(!isWasmInitialized) {
38114 throw new Error("initializeWasm() must be awaited first!");
38116 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
38117 // debug statements here
38119 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38121 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
38122 if(!isWasmInitialized) {
38123 throw new Error("initializeWasm() must be awaited first!");
38125 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
38126 // debug statements here
38128 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38130 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
38131 if(!isWasmInitialized) {
38132 throw new Error("initializeWasm() must be awaited first!");
38134 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
38135 return nativeResponseValue;
38137 // void Bolt11InvoiceFeatures_set_payment_secret_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38139 export function Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
38140 if(!isWasmInitialized) {
38141 throw new Error("initializeWasm() must be awaited first!");
38143 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg);
38144 // debug statements here
38146 // void Bolt11InvoiceFeatures_set_payment_secret_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38148 export function Bolt11InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
38149 if(!isWasmInitialized) {
38150 throw new Error("initializeWasm() must be awaited first!");
38152 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_required(this_arg);
38153 // debug statements here
38155 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38157 export function Bolt11InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
38158 if(!isWasmInitialized) {
38159 throw new Error("initializeWasm() must be awaited first!");
38161 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_secret(this_arg);
38162 return nativeResponseValue;
38164 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38166 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
38167 if(!isWasmInitialized) {
38168 throw new Error("initializeWasm() must be awaited first!");
38170 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
38171 return nativeResponseValue;
38173 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38175 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
38176 if(!isWasmInitialized) {
38177 throw new Error("initializeWasm() must be awaited first!");
38179 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
38180 return nativeResponseValue;
38182 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38184 export function Bolt11InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
38185 if(!isWasmInitialized) {
38186 throw new Error("initializeWasm() must be awaited first!");
38188 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_secret(this_arg);
38189 return nativeResponseValue;
38191 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38193 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
38194 if(!isWasmInitialized) {
38195 throw new Error("initializeWasm() must be awaited first!");
38197 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
38198 // debug statements here
38200 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38202 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
38203 if(!isWasmInitialized) {
38204 throw new Error("initializeWasm() must be awaited first!");
38206 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
38207 // debug statements here
38209 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38211 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
38212 if(!isWasmInitialized) {
38213 throw new Error("initializeWasm() must be awaited first!");
38215 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
38216 return nativeResponseValue;
38218 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38220 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
38221 if(!isWasmInitialized) {
38222 throw new Error("initializeWasm() must be awaited first!");
38224 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
38225 // debug statements here
38227 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38229 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
38230 if(!isWasmInitialized) {
38231 throw new Error("initializeWasm() must be awaited first!");
38233 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
38234 // debug statements here
38236 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38238 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
38239 if(!isWasmInitialized) {
38240 throw new Error("initializeWasm() must be awaited first!");
38242 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
38243 return nativeResponseValue;
38245 // void Bolt11InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38247 export function Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
38248 if(!isWasmInitialized) {
38249 throw new Error("initializeWasm() must be awaited first!");
38251 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg);
38252 // debug statements here
38254 // void Bolt11InvoiceFeatures_set_basic_mpp_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38256 export function Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
38257 if(!isWasmInitialized) {
38258 throw new Error("initializeWasm() must be awaited first!");
38260 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg);
38261 // debug statements here
38263 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38265 export function Bolt11InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
38266 if(!isWasmInitialized) {
38267 throw new Error("initializeWasm() must be awaited first!");
38269 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_basic_mpp(this_arg);
38270 return nativeResponseValue;
38272 // void Bolt12InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
38274 export function Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
38275 if(!isWasmInitialized) {
38276 throw new Error("initializeWasm() must be awaited first!");
38278 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg);
38279 // debug statements here
38281 // void Bolt12InvoiceFeatures_set_basic_mpp_required(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
38283 export function Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
38284 if(!isWasmInitialized) {
38285 throw new Error("initializeWasm() must be awaited first!");
38287 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg);
38288 // debug statements here
38290 // MUST_USE_RES bool Bolt12InvoiceFeatures_supports_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
38292 export function Bolt12InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
38293 if(!isWasmInitialized) {
38294 throw new Error("initializeWasm() must be awaited first!");
38296 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_supports_basic_mpp(this_arg);
38297 return nativeResponseValue;
38299 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38301 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
38302 if(!isWasmInitialized) {
38303 throw new Error("initializeWasm() must be awaited first!");
38305 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
38306 return nativeResponseValue;
38308 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38310 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
38311 if(!isWasmInitialized) {
38312 throw new Error("initializeWasm() must be awaited first!");
38314 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
38315 return nativeResponseValue;
38317 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38319 export function Bolt11InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
38320 if(!isWasmInitialized) {
38321 throw new Error("initializeWasm() must be awaited first!");
38323 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_basic_mpp(this_arg);
38324 return nativeResponseValue;
38326 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
38328 export function Bolt12InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
38329 if(!isWasmInitialized) {
38330 throw new Error("initializeWasm() must be awaited first!");
38332 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_basic_mpp(this_arg);
38333 return nativeResponseValue;
38335 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38337 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
38338 if(!isWasmInitialized) {
38339 throw new Error("initializeWasm() must be awaited first!");
38341 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
38342 // debug statements here
38344 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38346 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
38347 if(!isWasmInitialized) {
38348 throw new Error("initializeWasm() must be awaited first!");
38350 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
38351 // debug statements here
38353 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38355 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
38356 if(!isWasmInitialized) {
38357 throw new Error("initializeWasm() must be awaited first!");
38359 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
38360 return nativeResponseValue;
38362 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38364 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
38365 if(!isWasmInitialized) {
38366 throw new Error("initializeWasm() must be awaited first!");
38368 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
38369 // debug statements here
38371 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38373 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
38374 if(!isWasmInitialized) {
38375 throw new Error("initializeWasm() must be awaited first!");
38377 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
38378 // debug statements here
38380 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38382 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
38383 if(!isWasmInitialized) {
38384 throw new Error("initializeWasm() must be awaited first!");
38386 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
38387 return nativeResponseValue;
38389 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38391 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
38392 if(!isWasmInitialized) {
38393 throw new Error("initializeWasm() must be awaited first!");
38395 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
38396 return nativeResponseValue;
38398 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38400 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
38401 if(!isWasmInitialized) {
38402 throw new Error("initializeWasm() must be awaited first!");
38404 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
38405 return nativeResponseValue;
38407 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38409 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
38410 if(!isWasmInitialized) {
38411 throw new Error("initializeWasm() must be awaited first!");
38413 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
38414 // debug statements here
38416 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38418 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
38419 if(!isWasmInitialized) {
38420 throw new Error("initializeWasm() must be awaited first!");
38422 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
38423 // debug statements here
38425 // MUST_USE_RES bool InitFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38427 export function InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
38428 if(!isWasmInitialized) {
38429 throw new Error("initializeWasm() must be awaited first!");
38431 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
38432 return nativeResponseValue;
38434 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38436 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
38437 if(!isWasmInitialized) {
38438 throw new Error("initializeWasm() must be awaited first!");
38440 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
38441 // debug statements here
38443 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38445 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
38446 if(!isWasmInitialized) {
38447 throw new Error("initializeWasm() must be awaited first!");
38449 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
38450 // debug statements here
38452 // MUST_USE_RES bool NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38454 export function NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
38455 if(!isWasmInitialized) {
38456 throw new Error("initializeWasm() must be awaited first!");
38458 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
38459 return nativeResponseValue;
38461 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38463 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
38464 if(!isWasmInitialized) {
38465 throw new Error("initializeWasm() must be awaited first!");
38467 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
38468 // debug statements here
38470 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38472 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
38473 if(!isWasmInitialized) {
38474 throw new Error("initializeWasm() must be awaited first!");
38476 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
38477 // debug statements here
38479 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38481 export function ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
38482 if(!isWasmInitialized) {
38483 throw new Error("initializeWasm() must be awaited first!");
38485 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
38486 return nativeResponseValue;
38488 // MUST_USE_RES bool InitFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38490 export function InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
38491 if(!isWasmInitialized) {
38492 throw new Error("initializeWasm() must be awaited first!");
38494 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
38495 return nativeResponseValue;
38497 // MUST_USE_RES bool NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38499 export function NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
38500 if(!isWasmInitialized) {
38501 throw new Error("initializeWasm() must be awaited first!");
38503 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
38504 return nativeResponseValue;
38506 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38508 export function ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
38509 if(!isWasmInitialized) {
38510 throw new Error("initializeWasm() must be awaited first!");
38512 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
38513 return nativeResponseValue;
38515 // void InitFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38517 export function InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
38518 if(!isWasmInitialized) {
38519 throw new Error("initializeWasm() must be awaited first!");
38521 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
38522 // debug statements here
38524 // void InitFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38526 export function InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
38527 if(!isWasmInitialized) {
38528 throw new Error("initializeWasm() must be awaited first!");
38530 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
38531 // debug statements here
38533 // MUST_USE_RES bool InitFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38535 export function InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
38536 if(!isWasmInitialized) {
38537 throw new Error("initializeWasm() must be awaited first!");
38539 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
38540 return nativeResponseValue;
38542 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38544 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
38545 if(!isWasmInitialized) {
38546 throw new Error("initializeWasm() must be awaited first!");
38548 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
38549 // debug statements here
38551 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38553 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
38554 if(!isWasmInitialized) {
38555 throw new Error("initializeWasm() must be awaited first!");
38557 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
38558 // debug statements here
38560 // MUST_USE_RES bool NodeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38562 export function NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
38563 if(!isWasmInitialized) {
38564 throw new Error("initializeWasm() must be awaited first!");
38566 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
38567 return nativeResponseValue;
38569 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38571 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
38572 if(!isWasmInitialized) {
38573 throw new Error("initializeWasm() must be awaited first!");
38575 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
38576 // debug statements here
38578 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38580 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
38581 if(!isWasmInitialized) {
38582 throw new Error("initializeWasm() must be awaited first!");
38584 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
38585 // debug statements here
38587 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38589 export function ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
38590 if(!isWasmInitialized) {
38591 throw new Error("initializeWasm() must be awaited first!");
38593 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
38594 return nativeResponseValue;
38596 // MUST_USE_RES bool InitFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38598 export function InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
38599 if(!isWasmInitialized) {
38600 throw new Error("initializeWasm() must be awaited first!");
38602 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
38603 return nativeResponseValue;
38605 // MUST_USE_RES bool NodeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38607 export function NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
38608 if(!isWasmInitialized) {
38609 throw new Error("initializeWasm() must be awaited first!");
38611 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
38612 return nativeResponseValue;
38614 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38616 export function ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
38617 if(!isWasmInitialized) {
38618 throw new Error("initializeWasm() must be awaited first!");
38620 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
38621 return nativeResponseValue;
38623 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38625 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
38626 if(!isWasmInitialized) {
38627 throw new Error("initializeWasm() must be awaited first!");
38629 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
38630 // debug statements here
38632 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38634 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
38635 if(!isWasmInitialized) {
38636 throw new Error("initializeWasm() must be awaited first!");
38638 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
38639 // debug statements here
38641 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38643 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
38644 if(!isWasmInitialized) {
38645 throw new Error("initializeWasm() must be awaited first!");
38647 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
38648 return nativeResponseValue;
38650 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38652 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
38653 if(!isWasmInitialized) {
38654 throw new Error("initializeWasm() must be awaited first!");
38656 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
38657 // debug statements here
38659 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38661 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
38662 if(!isWasmInitialized) {
38663 throw new Error("initializeWasm() must be awaited first!");
38665 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
38666 // debug statements here
38668 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38670 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
38671 if(!isWasmInitialized) {
38672 throw new Error("initializeWasm() must be awaited first!");
38674 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
38675 return nativeResponseValue;
38677 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38679 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
38680 if(!isWasmInitialized) {
38681 throw new Error("initializeWasm() must be awaited first!");
38683 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
38684 return nativeResponseValue;
38686 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38688 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
38689 if(!isWasmInitialized) {
38690 throw new Error("initializeWasm() must be awaited first!");
38692 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
38693 return nativeResponseValue;
38695 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38697 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
38698 if(!isWasmInitialized) {
38699 throw new Error("initializeWasm() must be awaited first!");
38701 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
38702 // debug statements here
38704 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38706 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
38707 if(!isWasmInitialized) {
38708 throw new Error("initializeWasm() must be awaited first!");
38710 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
38711 // debug statements here
38713 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38715 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
38716 if(!isWasmInitialized) {
38717 throw new Error("initializeWasm() must be awaited first!");
38719 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
38720 return nativeResponseValue;
38722 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38724 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
38725 if(!isWasmInitialized) {
38726 throw new Error("initializeWasm() must be awaited first!");
38728 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
38729 // debug statements here
38731 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38733 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
38734 if(!isWasmInitialized) {
38735 throw new Error("initializeWasm() must be awaited first!");
38737 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
38738 // debug statements here
38740 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38742 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
38743 if(!isWasmInitialized) {
38744 throw new Error("initializeWasm() must be awaited first!");
38746 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
38747 return nativeResponseValue;
38749 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38751 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
38752 if(!isWasmInitialized) {
38753 throw new Error("initializeWasm() must be awaited first!");
38755 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
38756 return nativeResponseValue;
38758 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38760 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
38761 if(!isWasmInitialized) {
38762 throw new Error("initializeWasm() must be awaited first!");
38764 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
38765 return nativeResponseValue;
38767 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38769 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
38770 if(!isWasmInitialized) {
38771 throw new Error("initializeWasm() must be awaited first!");
38773 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
38774 // debug statements here
38776 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38778 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
38779 if(!isWasmInitialized) {
38780 throw new Error("initializeWasm() must be awaited first!");
38782 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
38783 // debug statements here
38785 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38787 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
38788 if(!isWasmInitialized) {
38789 throw new Error("initializeWasm() must be awaited first!");
38791 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
38792 return nativeResponseValue;
38794 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38796 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
38797 if(!isWasmInitialized) {
38798 throw new Error("initializeWasm() must be awaited first!");
38800 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
38801 // debug statements here
38803 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38805 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
38806 if(!isWasmInitialized) {
38807 throw new Error("initializeWasm() must be awaited first!");
38809 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
38810 // debug statements here
38812 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38814 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
38815 if(!isWasmInitialized) {
38816 throw new Error("initializeWasm() must be awaited first!");
38818 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
38819 return nativeResponseValue;
38821 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38823 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
38824 if(!isWasmInitialized) {
38825 throw new Error("initializeWasm() must be awaited first!");
38827 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
38828 return nativeResponseValue;
38830 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38832 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
38833 if(!isWasmInitialized) {
38834 throw new Error("initializeWasm() must be awaited first!");
38836 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
38837 return nativeResponseValue;
38839 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38841 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
38842 if(!isWasmInitialized) {
38843 throw new Error("initializeWasm() must be awaited first!");
38845 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
38846 // debug statements here
38848 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38850 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
38851 if(!isWasmInitialized) {
38852 throw new Error("initializeWasm() must be awaited first!");
38854 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
38855 // debug statements here
38857 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38859 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
38860 if(!isWasmInitialized) {
38861 throw new Error("initializeWasm() must be awaited first!");
38863 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
38864 return nativeResponseValue;
38866 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38868 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
38869 if(!isWasmInitialized) {
38870 throw new Error("initializeWasm() must be awaited first!");
38872 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
38873 // debug statements here
38875 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
38877 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
38878 if(!isWasmInitialized) {
38879 throw new Error("initializeWasm() must be awaited first!");
38881 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
38882 // debug statements here
38884 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38886 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
38887 if(!isWasmInitialized) {
38888 throw new Error("initializeWasm() must be awaited first!");
38890 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
38891 return nativeResponseValue;
38893 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38895 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
38896 if(!isWasmInitialized) {
38897 throw new Error("initializeWasm() must be awaited first!");
38899 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
38900 // debug statements here
38902 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38904 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
38905 if(!isWasmInitialized) {
38906 throw new Error("initializeWasm() must be awaited first!");
38908 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
38909 // debug statements here
38911 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38913 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
38914 if(!isWasmInitialized) {
38915 throw new Error("initializeWasm() must be awaited first!");
38917 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
38918 return nativeResponseValue;
38920 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38922 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
38923 if(!isWasmInitialized) {
38924 throw new Error("initializeWasm() must be awaited first!");
38926 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
38927 return nativeResponseValue;
38929 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38931 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
38932 if(!isWasmInitialized) {
38933 throw new Error("initializeWasm() must be awaited first!");
38935 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
38936 return nativeResponseValue;
38938 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
38940 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
38941 if(!isWasmInitialized) {
38942 throw new Error("initializeWasm() must be awaited first!");
38944 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
38945 return nativeResponseValue;
38947 // void Bolt11InvoiceFeatures_set_payment_metadata_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38949 export function Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg: bigint): void {
38950 if(!isWasmInitialized) {
38951 throw new Error("initializeWasm() must be awaited first!");
38953 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg);
38954 // debug statements here
38956 // void Bolt11InvoiceFeatures_set_payment_metadata_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38958 export function Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg: bigint): void {
38959 if(!isWasmInitialized) {
38960 throw new Error("initializeWasm() must be awaited first!");
38962 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg);
38963 // debug statements here
38965 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38967 export function Bolt11InvoiceFeatures_supports_payment_metadata(this_arg: bigint): boolean {
38968 if(!isWasmInitialized) {
38969 throw new Error("initializeWasm() must be awaited first!");
38971 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_metadata(this_arg);
38972 return nativeResponseValue;
38974 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38976 export function Bolt11InvoiceFeatures_requires_payment_metadata(this_arg: bigint): boolean {
38977 if(!isWasmInitialized) {
38978 throw new Error("initializeWasm() must be awaited first!");
38980 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_metadata(this_arg);
38981 return nativeResponseValue;
38983 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
38985 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
38986 if(!isWasmInitialized) {
38987 throw new Error("initializeWasm() must be awaited first!");
38989 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
38990 // debug statements here
38992 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
38994 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
38995 if(!isWasmInitialized) {
38996 throw new Error("initializeWasm() must be awaited first!");
38998 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
38999 // debug statements here
39001 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39003 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
39004 if(!isWasmInitialized) {
39005 throw new Error("initializeWasm() must be awaited first!");
39007 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
39008 return nativeResponseValue;
39010 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39012 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
39013 if(!isWasmInitialized) {
39014 throw new Error("initializeWasm() must be awaited first!");
39016 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
39017 // debug statements here
39019 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39021 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
39022 if(!isWasmInitialized) {
39023 throw new Error("initializeWasm() must be awaited first!");
39025 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
39026 // debug statements here
39028 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39030 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
39031 if(!isWasmInitialized) {
39032 throw new Error("initializeWasm() must be awaited first!");
39034 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
39035 return nativeResponseValue;
39037 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39039 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
39040 if(!isWasmInitialized) {
39041 throw new Error("initializeWasm() must be awaited first!");
39043 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
39044 // debug statements here
39046 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39048 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
39049 if(!isWasmInitialized) {
39050 throw new Error("initializeWasm() must be awaited first!");
39052 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
39053 // debug statements here
39055 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39057 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
39058 if(!isWasmInitialized) {
39059 throw new Error("initializeWasm() must be awaited first!");
39061 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
39062 return nativeResponseValue;
39064 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39066 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
39067 if(!isWasmInitialized) {
39068 throw new Error("initializeWasm() must be awaited first!");
39070 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
39071 return nativeResponseValue;
39073 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39075 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
39076 if(!isWasmInitialized) {
39077 throw new Error("initializeWasm() must be awaited first!");
39079 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
39080 return nativeResponseValue;
39082 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39084 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
39085 if(!isWasmInitialized) {
39086 throw new Error("initializeWasm() must be awaited first!");
39088 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
39089 return nativeResponseValue;
39091 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39093 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
39094 if(!isWasmInitialized) {
39095 throw new Error("initializeWasm() must be awaited first!");
39097 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
39098 // debug statements here
39100 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39102 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
39103 if(!isWasmInitialized) {
39104 throw new Error("initializeWasm() must be awaited first!");
39106 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
39107 // debug statements here
39109 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39111 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
39112 if(!isWasmInitialized) {
39113 throw new Error("initializeWasm() must be awaited first!");
39115 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
39116 return nativeResponseValue;
39118 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39120 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
39121 if(!isWasmInitialized) {
39122 throw new Error("initializeWasm() must be awaited first!");
39124 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
39125 return nativeResponseValue;
39127 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
39129 export function ShutdownScript_free(this_obj: bigint): void {
39130 if(!isWasmInitialized) {
39131 throw new Error("initializeWasm() must be awaited first!");
39133 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
39134 // debug statements here
39136 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
39138 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
39139 if(!isWasmInitialized) {
39140 throw new Error("initializeWasm() must be awaited first!");
39142 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
39143 return nativeResponseValue;
39145 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
39147 export function ShutdownScript_clone(orig: bigint): bigint {
39148 if(!isWasmInitialized) {
39149 throw new Error("initializeWasm() must be awaited first!");
39151 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
39152 return nativeResponseValue;
39154 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
39156 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
39157 if(!isWasmInitialized) {
39158 throw new Error("initializeWasm() must be awaited first!");
39160 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
39161 return nativeResponseValue;
39163 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
39165 export function InvalidShutdownScript_free(this_obj: bigint): void {
39166 if(!isWasmInitialized) {
39167 throw new Error("initializeWasm() must be awaited first!");
39169 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
39170 // debug statements here
39172 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
39174 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
39175 if(!isWasmInitialized) {
39176 throw new Error("initializeWasm() must be awaited first!");
39178 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
39179 return nativeResponseValue;
39181 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
39183 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
39184 if(!isWasmInitialized) {
39185 throw new Error("initializeWasm() must be awaited first!");
39187 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
39188 // debug statements here
39190 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
39192 export function InvalidShutdownScript_new(script_arg: number): bigint {
39193 if(!isWasmInitialized) {
39194 throw new Error("initializeWasm() must be awaited first!");
39196 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
39197 return nativeResponseValue;
39199 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
39201 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
39202 if(!isWasmInitialized) {
39203 throw new Error("initializeWasm() must be awaited first!");
39205 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
39206 return nativeResponseValue;
39208 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
39210 export function InvalidShutdownScript_clone(orig: bigint): bigint {
39211 if(!isWasmInitialized) {
39212 throw new Error("initializeWasm() must be awaited first!");
39214 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
39215 return nativeResponseValue;
39217 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
39219 export function ShutdownScript_write(obj: bigint): number {
39220 if(!isWasmInitialized) {
39221 throw new Error("initializeWasm() must be awaited first!");
39223 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
39224 return nativeResponseValue;
39226 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
39228 export function ShutdownScript_read(ser: number): bigint {
39229 if(!isWasmInitialized) {
39230 throw new Error("initializeWasm() must be awaited first!");
39232 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
39233 return nativeResponseValue;
39235 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
39237 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
39238 if(!isWasmInitialized) {
39239 throw new Error("initializeWasm() must be awaited first!");
39241 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
39242 return nativeResponseValue;
39244 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
39246 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
39247 if(!isWasmInitialized) {
39248 throw new Error("initializeWasm() must be awaited first!");
39250 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
39251 return nativeResponseValue;
39253 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
39255 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
39256 if(!isWasmInitialized) {
39257 throw new Error("initializeWasm() must be awaited first!");
39259 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
39260 return nativeResponseValue;
39262 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
39264 export function ShutdownScript_into_inner(this_arg: bigint): number {
39265 if(!isWasmInitialized) {
39266 throw new Error("initializeWasm() must be awaited first!");
39268 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
39269 return nativeResponseValue;
39271 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
39273 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
39274 if(!isWasmInitialized) {
39275 throw new Error("initializeWasm() must be awaited first!");
39277 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
39278 return nativeResponseValue;
39280 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
39282 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
39283 if(!isWasmInitialized) {
39284 throw new Error("initializeWasm() must be awaited first!");
39286 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
39287 return nativeResponseValue;
39289 // void Retry_free(struct LDKRetry this_ptr);
39291 export function Retry_free(this_ptr: bigint): void {
39292 if(!isWasmInitialized) {
39293 throw new Error("initializeWasm() must be awaited first!");
39295 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
39296 // debug statements here
39298 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
39300 export function Retry_clone_ptr(arg: bigint): bigint {
39301 if(!isWasmInitialized) {
39302 throw new Error("initializeWasm() must be awaited first!");
39304 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
39305 return nativeResponseValue;
39307 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
39309 export function Retry_clone(orig: bigint): bigint {
39310 if(!isWasmInitialized) {
39311 throw new Error("initializeWasm() must be awaited first!");
39313 const nativeResponseValue = wasm.TS_Retry_clone(orig);
39314 return nativeResponseValue;
39316 // struct LDKRetry Retry_attempts(uintptr_t a);
39318 export function Retry_attempts(a: number): bigint {
39319 if(!isWasmInitialized) {
39320 throw new Error("initializeWasm() must be awaited first!");
39322 const nativeResponseValue = wasm.TS_Retry_attempts(a);
39323 return nativeResponseValue;
39325 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
39327 export function Retry_eq(a: bigint, b: bigint): boolean {
39328 if(!isWasmInitialized) {
39329 throw new Error("initializeWasm() must be awaited first!");
39331 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
39332 return nativeResponseValue;
39334 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
39336 export function Retry_hash(o: bigint): bigint {
39337 if(!isWasmInitialized) {
39338 throw new Error("initializeWasm() must be awaited first!");
39340 const nativeResponseValue = wasm.TS_Retry_hash(o);
39341 return nativeResponseValue;
39343 // enum LDKRetryableSendFailure RetryableSendFailure_clone(const enum LDKRetryableSendFailure *NONNULL_PTR orig);
39345 export function RetryableSendFailure_clone(orig: bigint): RetryableSendFailure {
39346 if(!isWasmInitialized) {
39347 throw new Error("initializeWasm() must be awaited first!");
39349 const nativeResponseValue = wasm.TS_RetryableSendFailure_clone(orig);
39350 return nativeResponseValue;
39352 // enum LDKRetryableSendFailure RetryableSendFailure_payment_expired(void);
39354 export function RetryableSendFailure_payment_expired(): RetryableSendFailure {
39355 if(!isWasmInitialized) {
39356 throw new Error("initializeWasm() must be awaited first!");
39358 const nativeResponseValue = wasm.TS_RetryableSendFailure_payment_expired();
39359 return nativeResponseValue;
39361 // enum LDKRetryableSendFailure RetryableSendFailure_route_not_found(void);
39363 export function RetryableSendFailure_route_not_found(): RetryableSendFailure {
39364 if(!isWasmInitialized) {
39365 throw new Error("initializeWasm() must be awaited first!");
39367 const nativeResponseValue = wasm.TS_RetryableSendFailure_route_not_found();
39368 return nativeResponseValue;
39370 // enum LDKRetryableSendFailure RetryableSendFailure_duplicate_payment(void);
39372 export function RetryableSendFailure_duplicate_payment(): RetryableSendFailure {
39373 if(!isWasmInitialized) {
39374 throw new Error("initializeWasm() must be awaited first!");
39376 const nativeResponseValue = wasm.TS_RetryableSendFailure_duplicate_payment();
39377 return nativeResponseValue;
39379 // bool RetryableSendFailure_eq(const enum LDKRetryableSendFailure *NONNULL_PTR a, const enum LDKRetryableSendFailure *NONNULL_PTR b);
39381 export function RetryableSendFailure_eq(a: bigint, b: bigint): boolean {
39382 if(!isWasmInitialized) {
39383 throw new Error("initializeWasm() must be awaited first!");
39385 const nativeResponseValue = wasm.TS_RetryableSendFailure_eq(a, b);
39386 return nativeResponseValue;
39388 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
39390 export function PaymentSendFailure_free(this_ptr: bigint): void {
39391 if(!isWasmInitialized) {
39392 throw new Error("initializeWasm() must be awaited first!");
39394 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
39395 // debug statements here
39397 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
39399 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
39400 if(!isWasmInitialized) {
39401 throw new Error("initializeWasm() must be awaited first!");
39403 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
39404 return nativeResponseValue;
39406 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
39408 export function PaymentSendFailure_clone(orig: bigint): bigint {
39409 if(!isWasmInitialized) {
39410 throw new Error("initializeWasm() must be awaited first!");
39412 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
39413 return nativeResponseValue;
39415 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
39417 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
39418 if(!isWasmInitialized) {
39419 throw new Error("initializeWasm() must be awaited first!");
39421 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
39422 return nativeResponseValue;
39424 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
39426 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
39427 if(!isWasmInitialized) {
39428 throw new Error("initializeWasm() must be awaited first!");
39430 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
39431 return nativeResponseValue;
39433 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
39435 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
39436 if(!isWasmInitialized) {
39437 throw new Error("initializeWasm() must be awaited first!");
39439 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
39440 return nativeResponseValue;
39442 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
39444 export function PaymentSendFailure_duplicate_payment(): bigint {
39445 if(!isWasmInitialized) {
39446 throw new Error("initializeWasm() must be awaited first!");
39448 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
39449 return nativeResponseValue;
39451 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
39453 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
39454 if(!isWasmInitialized) {
39455 throw new Error("initializeWasm() must be awaited first!");
39457 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
39458 return nativeResponseValue;
39460 // void RecipientOnionFields_free(struct LDKRecipientOnionFields this_obj);
39462 export function RecipientOnionFields_free(this_obj: bigint): void {
39463 if(!isWasmInitialized) {
39464 throw new Error("initializeWasm() must be awaited first!");
39466 const nativeResponseValue = wasm.TS_RecipientOnionFields_free(this_obj);
39467 // debug statements here
39469 // struct LDKCOption_PaymentSecretZ RecipientOnionFields_get_payment_secret(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
39471 export function RecipientOnionFields_get_payment_secret(this_ptr: bigint): bigint {
39472 if(!isWasmInitialized) {
39473 throw new Error("initializeWasm() must be awaited first!");
39475 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_secret(this_ptr);
39476 return nativeResponseValue;
39478 // void RecipientOnionFields_set_payment_secret(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_PaymentSecretZ val);
39480 export function RecipientOnionFields_set_payment_secret(this_ptr: bigint, val: bigint): void {
39481 if(!isWasmInitialized) {
39482 throw new Error("initializeWasm() must be awaited first!");
39484 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_secret(this_ptr, val);
39485 // debug statements here
39487 // struct LDKCOption_CVec_u8ZZ RecipientOnionFields_get_payment_metadata(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
39489 export function RecipientOnionFields_get_payment_metadata(this_ptr: bigint): bigint {
39490 if(!isWasmInitialized) {
39491 throw new Error("initializeWasm() must be awaited first!");
39493 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_metadata(this_ptr);
39494 return nativeResponseValue;
39496 // void RecipientOnionFields_set_payment_metadata(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
39498 export function RecipientOnionFields_set_payment_metadata(this_ptr: bigint, val: bigint): void {
39499 if(!isWasmInitialized) {
39500 throw new Error("initializeWasm() must be awaited first!");
39502 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_metadata(this_ptr, val);
39503 // debug statements here
39505 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_new(struct LDKCOption_PaymentSecretZ payment_secret_arg, struct LDKCOption_CVec_u8ZZ payment_metadata_arg);
39507 export function RecipientOnionFields_new(payment_secret_arg: bigint, payment_metadata_arg: bigint): bigint {
39508 if(!isWasmInitialized) {
39509 throw new Error("initializeWasm() must be awaited first!");
39511 const nativeResponseValue = wasm.TS_RecipientOnionFields_new(payment_secret_arg, payment_metadata_arg);
39512 return nativeResponseValue;
39514 // uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg);
39516 export function RecipientOnionFields_clone_ptr(arg: bigint): bigint {
39517 if(!isWasmInitialized) {
39518 throw new Error("initializeWasm() must be awaited first!");
39520 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone_ptr(arg);
39521 return nativeResponseValue;
39523 // struct LDKRecipientOnionFields RecipientOnionFields_clone(const struct LDKRecipientOnionFields *NONNULL_PTR orig);
39525 export function RecipientOnionFields_clone(orig: bigint): bigint {
39526 if(!isWasmInitialized) {
39527 throw new Error("initializeWasm() must be awaited first!");
39529 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone(orig);
39530 return nativeResponseValue;
39532 // bool RecipientOnionFields_eq(const struct LDKRecipientOnionFields *NONNULL_PTR a, const struct LDKRecipientOnionFields *NONNULL_PTR b);
39534 export function RecipientOnionFields_eq(a: bigint, b: bigint): boolean {
39535 if(!isWasmInitialized) {
39536 throw new Error("initializeWasm() must be awaited first!");
39538 const nativeResponseValue = wasm.TS_RecipientOnionFields_eq(a, b);
39539 return nativeResponseValue;
39541 // struct LDKCVec_u8Z RecipientOnionFields_write(const struct LDKRecipientOnionFields *NONNULL_PTR obj);
39543 export function RecipientOnionFields_write(obj: bigint): number {
39544 if(!isWasmInitialized) {
39545 throw new Error("initializeWasm() must be awaited first!");
39547 const nativeResponseValue = wasm.TS_RecipientOnionFields_write(obj);
39548 return nativeResponseValue;
39550 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ RecipientOnionFields_read(struct LDKu8slice ser);
39552 export function RecipientOnionFields_read(ser: number): bigint {
39553 if(!isWasmInitialized) {
39554 throw new Error("initializeWasm() must be awaited first!");
39556 const nativeResponseValue = wasm.TS_RecipientOnionFields_read(ser);
39557 return nativeResponseValue;
39559 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_secret_only(struct LDKThirtyTwoBytes payment_secret);
39561 export function RecipientOnionFields_secret_only(payment_secret: number): bigint {
39562 if(!isWasmInitialized) {
39563 throw new Error("initializeWasm() must be awaited first!");
39565 const nativeResponseValue = wasm.TS_RecipientOnionFields_secret_only(payment_secret);
39566 return nativeResponseValue;
39568 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_spontaneous_empty(void);
39570 export function RecipientOnionFields_spontaneous_empty(): bigint {
39571 if(!isWasmInitialized) {
39572 throw new Error("initializeWasm() must be awaited first!");
39574 const nativeResponseValue = wasm.TS_RecipientOnionFields_spontaneous_empty();
39575 return nativeResponseValue;
39577 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
39579 export function CustomMessageReader_free(this_ptr: bigint): void {
39580 if(!isWasmInitialized) {
39581 throw new Error("initializeWasm() must be awaited first!");
39583 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
39584 // debug statements here
39586 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
39588 export function Type_clone_ptr(arg: bigint): bigint {
39589 if(!isWasmInitialized) {
39590 throw new Error("initializeWasm() must be awaited first!");
39592 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
39593 return nativeResponseValue;
39595 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
39597 export function Type_clone(orig: bigint): bigint {
39598 if(!isWasmInitialized) {
39599 throw new Error("initializeWasm() must be awaited first!");
39601 const nativeResponseValue = wasm.TS_Type_clone(orig);
39602 return nativeResponseValue;
39604 // void Type_free(struct LDKType this_ptr);
39606 export function Type_free(this_ptr: bigint): void {
39607 if(!isWasmInitialized) {
39608 throw new Error("initializeWasm() must be awaited first!");
39610 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
39611 // debug statements here
39613 // void UnsignedBolt12Invoice_free(struct LDKUnsignedBolt12Invoice this_obj);
39615 export function UnsignedBolt12Invoice_free(this_obj: bigint): void {
39616 if(!isWasmInitialized) {
39617 throw new Error("initializeWasm() must be awaited first!");
39619 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_free(this_obj);
39620 // debug statements here
39622 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_signing_pubkey(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
39624 export function UnsignedBolt12Invoice_signing_pubkey(this_arg: bigint): number {
39625 if(!isWasmInitialized) {
39626 throw new Error("initializeWasm() must be awaited first!");
39628 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_signing_pubkey(this_arg);
39629 return nativeResponseValue;
39631 // void Bolt12Invoice_free(struct LDKBolt12Invoice this_obj);
39633 export function Bolt12Invoice_free(this_obj: bigint): void {
39634 if(!isWasmInitialized) {
39635 throw new Error("initializeWasm() must be awaited first!");
39637 const nativeResponseValue = wasm.TS_Bolt12Invoice_free(this_obj);
39638 // debug statements here
39640 // uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg);
39642 export function Bolt12Invoice_clone_ptr(arg: bigint): bigint {
39643 if(!isWasmInitialized) {
39644 throw new Error("initializeWasm() must be awaited first!");
39646 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone_ptr(arg);
39647 return nativeResponseValue;
39649 // struct LDKBolt12Invoice Bolt12Invoice_clone(const struct LDKBolt12Invoice *NONNULL_PTR orig);
39651 export function Bolt12Invoice_clone(orig: bigint): bigint {
39652 if(!isWasmInitialized) {
39653 throw new Error("initializeWasm() must be awaited first!");
39655 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone(orig);
39656 return nativeResponseValue;
39658 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_description(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39660 export function Bolt12Invoice_description(this_arg: bigint): bigint {
39661 if(!isWasmInitialized) {
39662 throw new Error("initializeWasm() must be awaited first!");
39664 const nativeResponseValue = wasm.TS_Bolt12Invoice_description(this_arg);
39665 return nativeResponseValue;
39667 // MUST_USE_RES uint64_t Bolt12Invoice_created_at(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39669 export function Bolt12Invoice_created_at(this_arg: bigint): bigint {
39670 if(!isWasmInitialized) {
39671 throw new Error("initializeWasm() must be awaited first!");
39673 const nativeResponseValue = wasm.TS_Bolt12Invoice_created_at(this_arg);
39674 return nativeResponseValue;
39676 // MUST_USE_RES uint64_t Bolt12Invoice_relative_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39678 export function Bolt12Invoice_relative_expiry(this_arg: bigint): bigint {
39679 if(!isWasmInitialized) {
39680 throw new Error("initializeWasm() must be awaited first!");
39682 const nativeResponseValue = wasm.TS_Bolt12Invoice_relative_expiry(this_arg);
39683 return nativeResponseValue;
39685 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_payment_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39687 export function Bolt12Invoice_payment_hash(this_arg: bigint): number {
39688 if(!isWasmInitialized) {
39689 throw new Error("initializeWasm() must be awaited first!");
39691 const nativeResponseValue = wasm.TS_Bolt12Invoice_payment_hash(this_arg);
39692 return nativeResponseValue;
39694 // MUST_USE_RES uint64_t Bolt12Invoice_amount_msats(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39696 export function Bolt12Invoice_amount_msats(this_arg: bigint): bigint {
39697 if(!isWasmInitialized) {
39698 throw new Error("initializeWasm() must be awaited first!");
39700 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount_msats(this_arg);
39701 return nativeResponseValue;
39703 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12Invoice_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39705 export function Bolt12Invoice_features(this_arg: bigint): bigint {
39706 if(!isWasmInitialized) {
39707 throw new Error("initializeWasm() must be awaited first!");
39709 const nativeResponseValue = wasm.TS_Bolt12Invoice_features(this_arg);
39710 return nativeResponseValue;
39712 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_signing_pubkey(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39714 export function Bolt12Invoice_signing_pubkey(this_arg: bigint): number {
39715 if(!isWasmInitialized) {
39716 throw new Error("initializeWasm() must be awaited first!");
39718 const nativeResponseValue = wasm.TS_Bolt12Invoice_signing_pubkey(this_arg);
39719 return nativeResponseValue;
39721 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_signable_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
39723 export function Bolt12Invoice_signable_hash(this_arg: bigint): number {
39724 if(!isWasmInitialized) {
39725 throw new Error("initializeWasm() must be awaited first!");
39727 const nativeResponseValue = wasm.TS_Bolt12Invoice_signable_hash(this_arg);
39728 return nativeResponseValue;
39730 // MUST_USE_RES bool Bolt12Invoice_verify(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
39732 export function Bolt12Invoice_verify(this_arg: bigint, key: bigint): boolean {
39733 if(!isWasmInitialized) {
39734 throw new Error("initializeWasm() must be awaited first!");
39736 const nativeResponseValue = wasm.TS_Bolt12Invoice_verify(this_arg, key);
39737 return nativeResponseValue;
39739 // struct LDKCVec_u8Z Bolt12Invoice_write(const struct LDKBolt12Invoice *NONNULL_PTR obj);
39741 export function Bolt12Invoice_write(obj: bigint): number {
39742 if(!isWasmInitialized) {
39743 throw new Error("initializeWasm() must be awaited first!");
39745 const nativeResponseValue = wasm.TS_Bolt12Invoice_write(obj);
39746 return nativeResponseValue;
39748 // void BlindedPayInfo_free(struct LDKBlindedPayInfo this_obj);
39750 export function BlindedPayInfo_free(this_obj: bigint): void {
39751 if(!isWasmInitialized) {
39752 throw new Error("initializeWasm() must be awaited first!");
39754 const nativeResponseValue = wasm.TS_BlindedPayInfo_free(this_obj);
39755 // debug statements here
39757 // uint32_t BlindedPayInfo_get_fee_base_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
39759 export function BlindedPayInfo_get_fee_base_msat(this_ptr: bigint): number {
39760 if(!isWasmInitialized) {
39761 throw new Error("initializeWasm() must be awaited first!");
39763 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_base_msat(this_ptr);
39764 return nativeResponseValue;
39766 // void BlindedPayInfo_set_fee_base_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
39768 export function BlindedPayInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
39769 if(!isWasmInitialized) {
39770 throw new Error("initializeWasm() must be awaited first!");
39772 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_base_msat(this_ptr, val);
39773 // debug statements here
39775 // uint32_t BlindedPayInfo_get_fee_proportional_millionths(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
39777 export function BlindedPayInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
39778 if(!isWasmInitialized) {
39779 throw new Error("initializeWasm() must be awaited first!");
39781 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_proportional_millionths(this_ptr);
39782 return nativeResponseValue;
39784 // void BlindedPayInfo_set_fee_proportional_millionths(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
39786 export function BlindedPayInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
39787 if(!isWasmInitialized) {
39788 throw new Error("initializeWasm() must be awaited first!");
39790 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_proportional_millionths(this_ptr, val);
39791 // debug statements here
39793 // uint16_t BlindedPayInfo_get_cltv_expiry_delta(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
39795 export function BlindedPayInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
39796 if(!isWasmInitialized) {
39797 throw new Error("initializeWasm() must be awaited first!");
39799 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_cltv_expiry_delta(this_ptr);
39800 return nativeResponseValue;
39802 // void BlindedPayInfo_set_cltv_expiry_delta(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint16_t val);
39804 export function BlindedPayInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
39805 if(!isWasmInitialized) {
39806 throw new Error("initializeWasm() must be awaited first!");
39808 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_cltv_expiry_delta(this_ptr, val);
39809 // debug statements here
39811 // uint64_t BlindedPayInfo_get_htlc_minimum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
39813 export function BlindedPayInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
39814 if(!isWasmInitialized) {
39815 throw new Error("initializeWasm() must be awaited first!");
39817 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_minimum_msat(this_ptr);
39818 return nativeResponseValue;
39820 // void BlindedPayInfo_set_htlc_minimum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
39822 export function BlindedPayInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
39823 if(!isWasmInitialized) {
39824 throw new Error("initializeWasm() must be awaited first!");
39826 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_minimum_msat(this_ptr, val);
39827 // debug statements here
39829 // uint64_t BlindedPayInfo_get_htlc_maximum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
39831 export function BlindedPayInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
39832 if(!isWasmInitialized) {
39833 throw new Error("initializeWasm() must be awaited first!");
39835 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_maximum_msat(this_ptr);
39836 return nativeResponseValue;
39838 // void BlindedPayInfo_set_htlc_maximum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
39840 export function BlindedPayInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
39841 if(!isWasmInitialized) {
39842 throw new Error("initializeWasm() must be awaited first!");
39844 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_maximum_msat(this_ptr, val);
39845 // debug statements here
39847 // struct LDKBlindedHopFeatures BlindedPayInfo_get_features(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
39849 export function BlindedPayInfo_get_features(this_ptr: bigint): bigint {
39850 if(!isWasmInitialized) {
39851 throw new Error("initializeWasm() must be awaited first!");
39853 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_features(this_ptr);
39854 return nativeResponseValue;
39856 // void BlindedPayInfo_set_features(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
39858 export function BlindedPayInfo_set_features(this_ptr: bigint, val: bigint): void {
39859 if(!isWasmInitialized) {
39860 throw new Error("initializeWasm() must be awaited first!");
39862 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_features(this_ptr, val);
39863 // debug statements here
39865 // MUST_USE_RES struct LDKBlindedPayInfo BlindedPayInfo_new(uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKBlindedHopFeatures features_arg);
39867 export function BlindedPayInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, features_arg: bigint): bigint {
39868 if(!isWasmInitialized) {
39869 throw new Error("initializeWasm() must be awaited first!");
39871 const nativeResponseValue = wasm.TS_BlindedPayInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, features_arg);
39872 return nativeResponseValue;
39874 // uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg);
39876 export function BlindedPayInfo_clone_ptr(arg: bigint): bigint {
39877 if(!isWasmInitialized) {
39878 throw new Error("initializeWasm() must be awaited first!");
39880 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone_ptr(arg);
39881 return nativeResponseValue;
39883 // struct LDKBlindedPayInfo BlindedPayInfo_clone(const struct LDKBlindedPayInfo *NONNULL_PTR orig);
39885 export function BlindedPayInfo_clone(orig: bigint): bigint {
39886 if(!isWasmInitialized) {
39887 throw new Error("initializeWasm() must be awaited first!");
39889 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone(orig);
39890 return nativeResponseValue;
39892 // uint64_t BlindedPayInfo_hash(const struct LDKBlindedPayInfo *NONNULL_PTR o);
39894 export function BlindedPayInfo_hash(o: bigint): bigint {
39895 if(!isWasmInitialized) {
39896 throw new Error("initializeWasm() must be awaited first!");
39898 const nativeResponseValue = wasm.TS_BlindedPayInfo_hash(o);
39899 return nativeResponseValue;
39901 // bool BlindedPayInfo_eq(const struct LDKBlindedPayInfo *NONNULL_PTR a, const struct LDKBlindedPayInfo *NONNULL_PTR b);
39903 export function BlindedPayInfo_eq(a: bigint, b: bigint): boolean {
39904 if(!isWasmInitialized) {
39905 throw new Error("initializeWasm() must be awaited first!");
39907 const nativeResponseValue = wasm.TS_BlindedPayInfo_eq(a, b);
39908 return nativeResponseValue;
39910 // struct LDKCVec_u8Z BlindedPayInfo_write(const struct LDKBlindedPayInfo *NONNULL_PTR obj);
39912 export function BlindedPayInfo_write(obj: bigint): number {
39913 if(!isWasmInitialized) {
39914 throw new Error("initializeWasm() must be awaited first!");
39916 const nativeResponseValue = wasm.TS_BlindedPayInfo_write(obj);
39917 return nativeResponseValue;
39919 // struct LDKCResult_BlindedPayInfoDecodeErrorZ BlindedPayInfo_read(struct LDKu8slice ser);
39921 export function BlindedPayInfo_read(ser: number): bigint {
39922 if(!isWasmInitialized) {
39923 throw new Error("initializeWasm() must be awaited first!");
39925 const nativeResponseValue = wasm.TS_BlindedPayInfo_read(ser);
39926 return nativeResponseValue;
39928 // void InvoiceError_free(struct LDKInvoiceError this_obj);
39930 export function InvoiceError_free(this_obj: bigint): void {
39931 if(!isWasmInitialized) {
39932 throw new Error("initializeWasm() must be awaited first!");
39934 const nativeResponseValue = wasm.TS_InvoiceError_free(this_obj);
39935 // debug statements here
39937 // struct LDKErroneousField InvoiceError_get_erroneous_field(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
39939 export function InvoiceError_get_erroneous_field(this_ptr: bigint): bigint {
39940 if(!isWasmInitialized) {
39941 throw new Error("initializeWasm() must be awaited first!");
39943 const nativeResponseValue = wasm.TS_InvoiceError_get_erroneous_field(this_ptr);
39944 return nativeResponseValue;
39946 // void InvoiceError_set_erroneous_field(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKErroneousField val);
39948 export function InvoiceError_set_erroneous_field(this_ptr: bigint, val: bigint): void {
39949 if(!isWasmInitialized) {
39950 throw new Error("initializeWasm() must be awaited first!");
39952 const nativeResponseValue = wasm.TS_InvoiceError_set_erroneous_field(this_ptr, val);
39953 // debug statements here
39955 // struct LDKUntrustedString InvoiceError_get_message(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
39957 export function InvoiceError_get_message(this_ptr: bigint): bigint {
39958 if(!isWasmInitialized) {
39959 throw new Error("initializeWasm() must be awaited first!");
39961 const nativeResponseValue = wasm.TS_InvoiceError_get_message(this_ptr);
39962 return nativeResponseValue;
39964 // void InvoiceError_set_message(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
39966 export function InvoiceError_set_message(this_ptr: bigint, val: bigint): void {
39967 if(!isWasmInitialized) {
39968 throw new Error("initializeWasm() must be awaited first!");
39970 const nativeResponseValue = wasm.TS_InvoiceError_set_message(this_ptr, val);
39971 // debug statements here
39973 // MUST_USE_RES struct LDKInvoiceError InvoiceError_new(struct LDKErroneousField erroneous_field_arg, struct LDKUntrustedString message_arg);
39975 export function InvoiceError_new(erroneous_field_arg: bigint, message_arg: bigint): bigint {
39976 if(!isWasmInitialized) {
39977 throw new Error("initializeWasm() must be awaited first!");
39979 const nativeResponseValue = wasm.TS_InvoiceError_new(erroneous_field_arg, message_arg);
39980 return nativeResponseValue;
39982 // uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg);
39984 export function InvoiceError_clone_ptr(arg: bigint): bigint {
39985 if(!isWasmInitialized) {
39986 throw new Error("initializeWasm() must be awaited first!");
39988 const nativeResponseValue = wasm.TS_InvoiceError_clone_ptr(arg);
39989 return nativeResponseValue;
39991 // struct LDKInvoiceError InvoiceError_clone(const struct LDKInvoiceError *NONNULL_PTR orig);
39993 export function InvoiceError_clone(orig: bigint): bigint {
39994 if(!isWasmInitialized) {
39995 throw new Error("initializeWasm() must be awaited first!");
39997 const nativeResponseValue = wasm.TS_InvoiceError_clone(orig);
39998 return nativeResponseValue;
40000 // void ErroneousField_free(struct LDKErroneousField this_obj);
40002 export function ErroneousField_free(this_obj: bigint): void {
40003 if(!isWasmInitialized) {
40004 throw new Error("initializeWasm() must be awaited first!");
40006 const nativeResponseValue = wasm.TS_ErroneousField_free(this_obj);
40007 // debug statements here
40009 // uint64_t ErroneousField_get_tlv_fieldnum(const struct LDKErroneousField *NONNULL_PTR this_ptr);
40011 export function ErroneousField_get_tlv_fieldnum(this_ptr: bigint): bigint {
40012 if(!isWasmInitialized) {
40013 throw new Error("initializeWasm() must be awaited first!");
40015 const nativeResponseValue = wasm.TS_ErroneousField_get_tlv_fieldnum(this_ptr);
40016 return nativeResponseValue;
40018 // void ErroneousField_set_tlv_fieldnum(struct LDKErroneousField *NONNULL_PTR this_ptr, uint64_t val);
40020 export function ErroneousField_set_tlv_fieldnum(this_ptr: bigint, val: bigint): void {
40021 if(!isWasmInitialized) {
40022 throw new Error("initializeWasm() must be awaited first!");
40024 const nativeResponseValue = wasm.TS_ErroneousField_set_tlv_fieldnum(this_ptr, val);
40025 // debug statements here
40027 // struct LDKCOption_CVec_u8ZZ ErroneousField_get_suggested_value(const struct LDKErroneousField *NONNULL_PTR this_ptr);
40029 export function ErroneousField_get_suggested_value(this_ptr: bigint): bigint {
40030 if(!isWasmInitialized) {
40031 throw new Error("initializeWasm() must be awaited first!");
40033 const nativeResponseValue = wasm.TS_ErroneousField_get_suggested_value(this_ptr);
40034 return nativeResponseValue;
40036 // void ErroneousField_set_suggested_value(struct LDKErroneousField *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
40038 export function ErroneousField_set_suggested_value(this_ptr: bigint, val: bigint): void {
40039 if(!isWasmInitialized) {
40040 throw new Error("initializeWasm() must be awaited first!");
40042 const nativeResponseValue = wasm.TS_ErroneousField_set_suggested_value(this_ptr, val);
40043 // debug statements here
40045 // MUST_USE_RES struct LDKErroneousField ErroneousField_new(uint64_t tlv_fieldnum_arg, struct LDKCOption_CVec_u8ZZ suggested_value_arg);
40047 export function ErroneousField_new(tlv_fieldnum_arg: bigint, suggested_value_arg: bigint): bigint {
40048 if(!isWasmInitialized) {
40049 throw new Error("initializeWasm() must be awaited first!");
40051 const nativeResponseValue = wasm.TS_ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg);
40052 return nativeResponseValue;
40054 // uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg);
40056 export function ErroneousField_clone_ptr(arg: bigint): bigint {
40057 if(!isWasmInitialized) {
40058 throw new Error("initializeWasm() must be awaited first!");
40060 const nativeResponseValue = wasm.TS_ErroneousField_clone_ptr(arg);
40061 return nativeResponseValue;
40063 // struct LDKErroneousField ErroneousField_clone(const struct LDKErroneousField *NONNULL_PTR orig);
40065 export function ErroneousField_clone(orig: bigint): bigint {
40066 if(!isWasmInitialized) {
40067 throw new Error("initializeWasm() must be awaited first!");
40069 const nativeResponseValue = wasm.TS_ErroneousField_clone(orig);
40070 return nativeResponseValue;
40072 // struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
40074 export function InvoiceError_write(obj: bigint): number {
40075 if(!isWasmInitialized) {
40076 throw new Error("initializeWasm() must be awaited first!");
40078 const nativeResponseValue = wasm.TS_InvoiceError_write(obj);
40079 return nativeResponseValue;
40081 // struct LDKCResult_InvoiceErrorDecodeErrorZ InvoiceError_read(struct LDKu8slice ser);
40083 export function InvoiceError_read(ser: number): bigint {
40084 if(!isWasmInitialized) {
40085 throw new Error("initializeWasm() must be awaited first!");
40087 const nativeResponseValue = wasm.TS_InvoiceError_read(ser);
40088 return nativeResponseValue;
40090 // void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
40092 export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
40093 if(!isWasmInitialized) {
40094 throw new Error("initializeWasm() must be awaited first!");
40096 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
40097 // debug statements here
40099 // void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
40101 export function InvoiceRequest_free(this_obj: bigint): void {
40102 if(!isWasmInitialized) {
40103 throw new Error("initializeWasm() must be awaited first!");
40105 const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
40106 // debug statements here
40108 // uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
40110 export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
40111 if(!isWasmInitialized) {
40112 throw new Error("initializeWasm() must be awaited first!");
40114 const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
40115 return nativeResponseValue;
40117 // struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
40119 export function InvoiceRequest_clone(orig: bigint): bigint {
40120 if(!isWasmInitialized) {
40121 throw new Error("initializeWasm() must be awaited first!");
40123 const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
40124 return nativeResponseValue;
40126 // MUST_USE_RES struct LDKu8slice InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40128 export function InvoiceRequest_metadata(this_arg: bigint): number {
40129 if(!isWasmInitialized) {
40130 throw new Error("initializeWasm() must be awaited first!");
40132 const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
40133 return nativeResponseValue;
40135 // MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40137 export function InvoiceRequest_chain(this_arg: bigint): number {
40138 if(!isWasmInitialized) {
40139 throw new Error("initializeWasm() must be awaited first!");
40141 const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
40142 return nativeResponseValue;
40144 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40146 export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
40147 if(!isWasmInitialized) {
40148 throw new Error("initializeWasm() must be awaited first!");
40150 const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
40151 return nativeResponseValue;
40153 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40155 export function InvoiceRequest_features(this_arg: bigint): bigint {
40156 if(!isWasmInitialized) {
40157 throw new Error("initializeWasm() must be awaited first!");
40159 const nativeResponseValue = wasm.TS_InvoiceRequest_features(this_arg);
40160 return nativeResponseValue;
40162 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40164 export function InvoiceRequest_quantity(this_arg: bigint): bigint {
40165 if(!isWasmInitialized) {
40166 throw new Error("initializeWasm() must be awaited first!");
40168 const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
40169 return nativeResponseValue;
40171 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40173 export function InvoiceRequest_payer_id(this_arg: bigint): number {
40174 if(!isWasmInitialized) {
40175 throw new Error("initializeWasm() must be awaited first!");
40177 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
40178 return nativeResponseValue;
40180 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
40182 export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
40183 if(!isWasmInitialized) {
40184 throw new Error("initializeWasm() must be awaited first!");
40186 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
40187 return nativeResponseValue;
40189 // MUST_USE_RES struct LDKCResult_COption_KeyPairZNoneZ InvoiceRequest_verify(const struct LDKInvoiceRequest *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
40191 export function InvoiceRequest_verify(this_arg: bigint, key: bigint): bigint {
40192 if(!isWasmInitialized) {
40193 throw new Error("initializeWasm() must be awaited first!");
40195 const nativeResponseValue = wasm.TS_InvoiceRequest_verify(this_arg, key);
40196 return nativeResponseValue;
40198 // struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
40200 export function InvoiceRequest_write(obj: bigint): number {
40201 if(!isWasmInitialized) {
40202 throw new Error("initializeWasm() must be awaited first!");
40204 const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
40205 return nativeResponseValue;
40207 // void Offer_free(struct LDKOffer this_obj);
40209 export function Offer_free(this_obj: bigint): void {
40210 if(!isWasmInitialized) {
40211 throw new Error("initializeWasm() must be awaited first!");
40213 const nativeResponseValue = wasm.TS_Offer_free(this_obj);
40214 // debug statements here
40216 // uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
40218 export function Offer_clone_ptr(arg: bigint): bigint {
40219 if(!isWasmInitialized) {
40220 throw new Error("initializeWasm() must be awaited first!");
40222 const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
40223 return nativeResponseValue;
40225 // struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
40227 export function Offer_clone(orig: bigint): bigint {
40228 if(!isWasmInitialized) {
40229 throw new Error("initializeWasm() must be awaited first!");
40231 const nativeResponseValue = wasm.TS_Offer_clone(orig);
40232 return nativeResponseValue;
40234 // MUST_USE_RES struct LDKCVec_ChainHashZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
40236 export function Offer_chains(this_arg: bigint): number {
40237 if(!isWasmInitialized) {
40238 throw new Error("initializeWasm() must be awaited first!");
40240 const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
40241 return nativeResponseValue;
40243 // MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
40245 export function Offer_supports_chain(this_arg: bigint, chain: number): boolean {
40246 if(!isWasmInitialized) {
40247 throw new Error("initializeWasm() must be awaited first!");
40249 const nativeResponseValue = wasm.TS_Offer_supports_chain(this_arg, chain);
40250 return nativeResponseValue;
40252 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
40254 export function Offer_metadata(this_arg: bigint): bigint {
40255 if(!isWasmInitialized) {
40256 throw new Error("initializeWasm() must be awaited first!");
40258 const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
40259 return nativeResponseValue;
40261 // MUST_USE_RES struct LDKAmount Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
40263 export function Offer_amount(this_arg: bigint): bigint {
40264 if(!isWasmInitialized) {
40265 throw new Error("initializeWasm() must be awaited first!");
40267 const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
40268 return nativeResponseValue;
40270 // MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
40272 export function Offer_description(this_arg: bigint): bigint {
40273 if(!isWasmInitialized) {
40274 throw new Error("initializeWasm() must be awaited first!");
40276 const nativeResponseValue = wasm.TS_Offer_description(this_arg);
40277 return nativeResponseValue;
40279 // MUST_USE_RES struct LDKOfferFeatures Offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
40281 export function Offer_features(this_arg: bigint): bigint {
40282 if(!isWasmInitialized) {
40283 throw new Error("initializeWasm() must be awaited first!");
40285 const nativeResponseValue = wasm.TS_Offer_features(this_arg);
40286 return nativeResponseValue;
40288 // MUST_USE_RES struct LDKCOption_DurationZ Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
40290 export function Offer_absolute_expiry(this_arg: bigint): bigint {
40291 if(!isWasmInitialized) {
40292 throw new Error("initializeWasm() must be awaited first!");
40294 const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
40295 return nativeResponseValue;
40297 // MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
40299 export function Offer_issuer(this_arg: bigint): bigint {
40300 if(!isWasmInitialized) {
40301 throw new Error("initializeWasm() must be awaited first!");
40303 const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
40304 return nativeResponseValue;
40306 // MUST_USE_RES struct LDKCVec_BlindedPathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
40308 export function Offer_paths(this_arg: bigint): number {
40309 if(!isWasmInitialized) {
40310 throw new Error("initializeWasm() must be awaited first!");
40312 const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
40313 return nativeResponseValue;
40315 // MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
40317 export function Offer_supported_quantity(this_arg: bigint): bigint {
40318 if(!isWasmInitialized) {
40319 throw new Error("initializeWasm() must be awaited first!");
40321 const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
40322 return nativeResponseValue;
40324 // MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
40326 export function Offer_is_valid_quantity(this_arg: bigint, quantity: bigint): boolean {
40327 if(!isWasmInitialized) {
40328 throw new Error("initializeWasm() must be awaited first!");
40330 const nativeResponseValue = wasm.TS_Offer_is_valid_quantity(this_arg, quantity);
40331 return nativeResponseValue;
40333 // MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
40335 export function Offer_expects_quantity(this_arg: bigint): boolean {
40336 if(!isWasmInitialized) {
40337 throw new Error("initializeWasm() must be awaited first!");
40339 const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
40340 return nativeResponseValue;
40342 // MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
40344 export function Offer_signing_pubkey(this_arg: bigint): number {
40345 if(!isWasmInitialized) {
40346 throw new Error("initializeWasm() must be awaited first!");
40348 const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
40349 return nativeResponseValue;
40351 // struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
40353 export function Offer_write(obj: bigint): number {
40354 if(!isWasmInitialized) {
40355 throw new Error("initializeWasm() must be awaited first!");
40357 const nativeResponseValue = wasm.TS_Offer_write(obj);
40358 return nativeResponseValue;
40360 // void Amount_free(struct LDKAmount this_obj);
40362 export function Amount_free(this_obj: bigint): void {
40363 if(!isWasmInitialized) {
40364 throw new Error("initializeWasm() must be awaited first!");
40366 const nativeResponseValue = wasm.TS_Amount_free(this_obj);
40367 // debug statements here
40369 // uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
40371 export function Amount_clone_ptr(arg: bigint): bigint {
40372 if(!isWasmInitialized) {
40373 throw new Error("initializeWasm() must be awaited first!");
40375 const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
40376 return nativeResponseValue;
40378 // struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
40380 export function Amount_clone(orig: bigint): bigint {
40381 if(!isWasmInitialized) {
40382 throw new Error("initializeWasm() must be awaited first!");
40384 const nativeResponseValue = wasm.TS_Amount_clone(orig);
40385 return nativeResponseValue;
40387 // void Quantity_free(struct LDKQuantity this_obj);
40389 export function Quantity_free(this_obj: bigint): void {
40390 if(!isWasmInitialized) {
40391 throw new Error("initializeWasm() must be awaited first!");
40393 const nativeResponseValue = wasm.TS_Quantity_free(this_obj);
40394 // debug statements here
40396 // uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
40398 export function Quantity_clone_ptr(arg: bigint): bigint {
40399 if(!isWasmInitialized) {
40400 throw new Error("initializeWasm() must be awaited first!");
40402 const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
40403 return nativeResponseValue;
40405 // struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
40407 export function Quantity_clone(orig: bigint): bigint {
40408 if(!isWasmInitialized) {
40409 throw new Error("initializeWasm() must be awaited first!");
40411 const nativeResponseValue = wasm.TS_Quantity_clone(orig);
40412 return nativeResponseValue;
40414 // struct LDKCResult_OfferBolt12ParseErrorZ Offer_from_str(struct LDKStr s);
40416 export function Offer_from_str(s: number): bigint {
40417 if(!isWasmInitialized) {
40418 throw new Error("initializeWasm() must be awaited first!");
40420 const nativeResponseValue = wasm.TS_Offer_from_str(s);
40421 return nativeResponseValue;
40423 // void Bolt12ParseError_free(struct LDKBolt12ParseError this_obj);
40425 export function Bolt12ParseError_free(this_obj: bigint): void {
40426 if(!isWasmInitialized) {
40427 throw new Error("initializeWasm() must be awaited first!");
40429 const nativeResponseValue = wasm.TS_Bolt12ParseError_free(this_obj);
40430 // debug statements here
40432 // uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg);
40434 export function Bolt12ParseError_clone_ptr(arg: bigint): bigint {
40435 if(!isWasmInitialized) {
40436 throw new Error("initializeWasm() must be awaited first!");
40438 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone_ptr(arg);
40439 return nativeResponseValue;
40441 // struct LDKBolt12ParseError Bolt12ParseError_clone(const struct LDKBolt12ParseError *NONNULL_PTR orig);
40443 export function Bolt12ParseError_clone(orig: bigint): bigint {
40444 if(!isWasmInitialized) {
40445 throw new Error("initializeWasm() must be awaited first!");
40447 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone(orig);
40448 return nativeResponseValue;
40450 // enum LDKBolt12SemanticError Bolt12SemanticError_clone(const enum LDKBolt12SemanticError *NONNULL_PTR orig);
40452 export function Bolt12SemanticError_clone(orig: bigint): Bolt12SemanticError {
40453 if(!isWasmInitialized) {
40454 throw new Error("initializeWasm() must be awaited first!");
40456 const nativeResponseValue = wasm.TS_Bolt12SemanticError_clone(orig);
40457 return nativeResponseValue;
40459 // enum LDKBolt12SemanticError Bolt12SemanticError_already_expired(void);
40461 export function Bolt12SemanticError_already_expired(): Bolt12SemanticError {
40462 if(!isWasmInitialized) {
40463 throw new Error("initializeWasm() must be awaited first!");
40465 const nativeResponseValue = wasm.TS_Bolt12SemanticError_already_expired();
40466 return nativeResponseValue;
40468 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_chain(void);
40470 export function Bolt12SemanticError_unsupported_chain(): Bolt12SemanticError {
40471 if(!isWasmInitialized) {
40472 throw new Error("initializeWasm() must be awaited first!");
40474 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_chain();
40475 return nativeResponseValue;
40477 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_chain(void);
40479 export function Bolt12SemanticError_unexpected_chain(): Bolt12SemanticError {
40480 if(!isWasmInitialized) {
40481 throw new Error("initializeWasm() must be awaited first!");
40483 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_chain();
40484 return nativeResponseValue;
40486 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_amount(void);
40488 export function Bolt12SemanticError_missing_amount(): Bolt12SemanticError {
40489 if(!isWasmInitialized) {
40490 throw new Error("initializeWasm() must be awaited first!");
40492 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_amount();
40493 return nativeResponseValue;
40495 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_amount(void);
40497 export function Bolt12SemanticError_invalid_amount(): Bolt12SemanticError {
40498 if(!isWasmInitialized) {
40499 throw new Error("initializeWasm() must be awaited first!");
40501 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_amount();
40502 return nativeResponseValue;
40504 // enum LDKBolt12SemanticError Bolt12SemanticError_insufficient_amount(void);
40506 export function Bolt12SemanticError_insufficient_amount(): Bolt12SemanticError {
40507 if(!isWasmInitialized) {
40508 throw new Error("initializeWasm() must be awaited first!");
40510 const nativeResponseValue = wasm.TS_Bolt12SemanticError_insufficient_amount();
40511 return nativeResponseValue;
40513 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_amount(void);
40515 export function Bolt12SemanticError_unexpected_amount(): Bolt12SemanticError {
40516 if(!isWasmInitialized) {
40517 throw new Error("initializeWasm() must be awaited first!");
40519 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_amount();
40520 return nativeResponseValue;
40522 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_currency(void);
40524 export function Bolt12SemanticError_unsupported_currency(): Bolt12SemanticError {
40525 if(!isWasmInitialized) {
40526 throw new Error("initializeWasm() must be awaited first!");
40528 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_currency();
40529 return nativeResponseValue;
40531 // enum LDKBolt12SemanticError Bolt12SemanticError_unknown_required_features(void);
40533 export function Bolt12SemanticError_unknown_required_features(): Bolt12SemanticError {
40534 if(!isWasmInitialized) {
40535 throw new Error("initializeWasm() must be awaited first!");
40537 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unknown_required_features();
40538 return nativeResponseValue;
40540 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_features(void);
40542 export function Bolt12SemanticError_unexpected_features(): Bolt12SemanticError {
40543 if(!isWasmInitialized) {
40544 throw new Error("initializeWasm() must be awaited first!");
40546 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_features();
40547 return nativeResponseValue;
40549 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_description(void);
40551 export function Bolt12SemanticError_missing_description(): Bolt12SemanticError {
40552 if(!isWasmInitialized) {
40553 throw new Error("initializeWasm() must be awaited first!");
40555 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_description();
40556 return nativeResponseValue;
40558 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signing_pubkey(void);
40560 export function Bolt12SemanticError_missing_signing_pubkey(): Bolt12SemanticError {
40561 if(!isWasmInitialized) {
40562 throw new Error("initializeWasm() must be awaited first!");
40564 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signing_pubkey();
40565 return nativeResponseValue;
40567 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_signing_pubkey(void);
40569 export function Bolt12SemanticError_invalid_signing_pubkey(): Bolt12SemanticError {
40570 if(!isWasmInitialized) {
40571 throw new Error("initializeWasm() must be awaited first!");
40573 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_signing_pubkey();
40574 return nativeResponseValue;
40576 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_signing_pubkey(void);
40578 export function Bolt12SemanticError_unexpected_signing_pubkey(): Bolt12SemanticError {
40579 if(!isWasmInitialized) {
40580 throw new Error("initializeWasm() must be awaited first!");
40582 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_signing_pubkey();
40583 return nativeResponseValue;
40585 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_quantity(void);
40587 export function Bolt12SemanticError_missing_quantity(): Bolt12SemanticError {
40588 if(!isWasmInitialized) {
40589 throw new Error("initializeWasm() must be awaited first!");
40591 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_quantity();
40592 return nativeResponseValue;
40594 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_quantity(void);
40596 export function Bolt12SemanticError_invalid_quantity(): Bolt12SemanticError {
40597 if(!isWasmInitialized) {
40598 throw new Error("initializeWasm() must be awaited first!");
40600 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_quantity();
40601 return nativeResponseValue;
40603 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_quantity(void);
40605 export function Bolt12SemanticError_unexpected_quantity(): Bolt12SemanticError {
40606 if(!isWasmInitialized) {
40607 throw new Error("initializeWasm() must be awaited first!");
40609 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_quantity();
40610 return nativeResponseValue;
40612 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_metadata(void);
40614 export function Bolt12SemanticError_invalid_metadata(): Bolt12SemanticError {
40615 if(!isWasmInitialized) {
40616 throw new Error("initializeWasm() must be awaited first!");
40618 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_metadata();
40619 return nativeResponseValue;
40621 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_metadata(void);
40623 export function Bolt12SemanticError_unexpected_metadata(): Bolt12SemanticError {
40624 if(!isWasmInitialized) {
40625 throw new Error("initializeWasm() must be awaited first!");
40627 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_metadata();
40628 return nativeResponseValue;
40630 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_metadata(void);
40632 export function Bolt12SemanticError_missing_payer_metadata(): Bolt12SemanticError {
40633 if(!isWasmInitialized) {
40634 throw new Error("initializeWasm() must be awaited first!");
40636 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_metadata();
40637 return nativeResponseValue;
40639 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_id(void);
40641 export function Bolt12SemanticError_missing_payer_id(): Bolt12SemanticError {
40642 if(!isWasmInitialized) {
40643 throw new Error("initializeWasm() must be awaited first!");
40645 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_id();
40646 return nativeResponseValue;
40648 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_paths(void);
40650 export function Bolt12SemanticError_missing_paths(): Bolt12SemanticError {
40651 if(!isWasmInitialized) {
40652 throw new Error("initializeWasm() must be awaited first!");
40654 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_paths();
40655 return nativeResponseValue;
40657 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_pay_info(void);
40659 export function Bolt12SemanticError_invalid_pay_info(): Bolt12SemanticError {
40660 if(!isWasmInitialized) {
40661 throw new Error("initializeWasm() must be awaited first!");
40663 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_pay_info();
40664 return nativeResponseValue;
40666 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_creation_time(void);
40668 export function Bolt12SemanticError_missing_creation_time(): Bolt12SemanticError {
40669 if(!isWasmInitialized) {
40670 throw new Error("initializeWasm() must be awaited first!");
40672 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_creation_time();
40673 return nativeResponseValue;
40675 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payment_hash(void);
40677 export function Bolt12SemanticError_missing_payment_hash(): Bolt12SemanticError {
40678 if(!isWasmInitialized) {
40679 throw new Error("initializeWasm() must be awaited first!");
40681 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payment_hash();
40682 return nativeResponseValue;
40684 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signature(void);
40686 export function Bolt12SemanticError_missing_signature(): Bolt12SemanticError {
40687 if(!isWasmInitialized) {
40688 throw new Error("initializeWasm() must be awaited first!");
40690 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signature();
40691 return nativeResponseValue;
40693 // void Refund_free(struct LDKRefund this_obj);
40695 export function Refund_free(this_obj: bigint): void {
40696 if(!isWasmInitialized) {
40697 throw new Error("initializeWasm() must be awaited first!");
40699 const nativeResponseValue = wasm.TS_Refund_free(this_obj);
40700 // debug statements here
40702 // uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
40704 export function Refund_clone_ptr(arg: bigint): bigint {
40705 if(!isWasmInitialized) {
40706 throw new Error("initializeWasm() must be awaited first!");
40708 const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
40709 return nativeResponseValue;
40711 // struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
40713 export function Refund_clone(orig: bigint): bigint {
40714 if(!isWasmInitialized) {
40715 throw new Error("initializeWasm() must be awaited first!");
40717 const nativeResponseValue = wasm.TS_Refund_clone(orig);
40718 return nativeResponseValue;
40720 // MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
40722 export function Refund_description(this_arg: bigint): bigint {
40723 if(!isWasmInitialized) {
40724 throw new Error("initializeWasm() must be awaited first!");
40726 const nativeResponseValue = wasm.TS_Refund_description(this_arg);
40727 return nativeResponseValue;
40729 // MUST_USE_RES struct LDKCOption_DurationZ Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
40731 export function Refund_absolute_expiry(this_arg: bigint): bigint {
40732 if(!isWasmInitialized) {
40733 throw new Error("initializeWasm() must be awaited first!");
40735 const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
40736 return nativeResponseValue;
40738 // MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
40740 export function Refund_issuer(this_arg: bigint): bigint {
40741 if(!isWasmInitialized) {
40742 throw new Error("initializeWasm() must be awaited first!");
40744 const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
40745 return nativeResponseValue;
40747 // MUST_USE_RES struct LDKCVec_BlindedPathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
40749 export function Refund_paths(this_arg: bigint): number {
40750 if(!isWasmInitialized) {
40751 throw new Error("initializeWasm() must be awaited first!");
40753 const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
40754 return nativeResponseValue;
40756 // MUST_USE_RES struct LDKu8slice Refund_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
40758 export function Refund_metadata(this_arg: bigint): number {
40759 if(!isWasmInitialized) {
40760 throw new Error("initializeWasm() must be awaited first!");
40762 const nativeResponseValue = wasm.TS_Refund_metadata(this_arg);
40763 return nativeResponseValue;
40765 // MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
40767 export function Refund_chain(this_arg: bigint): number {
40768 if(!isWasmInitialized) {
40769 throw new Error("initializeWasm() must be awaited first!");
40771 const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
40772 return nativeResponseValue;
40774 // MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
40776 export function Refund_amount_msats(this_arg: bigint): bigint {
40777 if(!isWasmInitialized) {
40778 throw new Error("initializeWasm() must be awaited first!");
40780 const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
40781 return nativeResponseValue;
40783 // MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
40785 export function Refund_features(this_arg: bigint): bigint {
40786 if(!isWasmInitialized) {
40787 throw new Error("initializeWasm() must be awaited first!");
40789 const nativeResponseValue = wasm.TS_Refund_features(this_arg);
40790 return nativeResponseValue;
40792 // MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
40794 export function Refund_quantity(this_arg: bigint): bigint {
40795 if(!isWasmInitialized) {
40796 throw new Error("initializeWasm() must be awaited first!");
40798 const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
40799 return nativeResponseValue;
40801 // MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
40803 export function Refund_payer_id(this_arg: bigint): number {
40804 if(!isWasmInitialized) {
40805 throw new Error("initializeWasm() must be awaited first!");
40807 const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
40808 return nativeResponseValue;
40810 // MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
40812 export function Refund_payer_note(this_arg: bigint): bigint {
40813 if(!isWasmInitialized) {
40814 throw new Error("initializeWasm() must be awaited first!");
40816 const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
40817 return nativeResponseValue;
40819 // struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
40821 export function Refund_write(obj: bigint): number {
40822 if(!isWasmInitialized) {
40823 throw new Error("initializeWasm() must be awaited first!");
40825 const nativeResponseValue = wasm.TS_Refund_write(obj);
40826 return nativeResponseValue;
40828 // struct LDKCResult_RefundBolt12ParseErrorZ Refund_from_str(struct LDKStr s);
40830 export function Refund_from_str(s: number): bigint {
40831 if(!isWasmInitialized) {
40832 throw new Error("initializeWasm() must be awaited first!");
40834 const nativeResponseValue = wasm.TS_Refund_from_str(s);
40835 return nativeResponseValue;
40837 // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
40839 export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
40840 if(!isWasmInitialized) {
40841 throw new Error("initializeWasm() must be awaited first!");
40843 const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
40844 return nativeResponseValue;
40846 // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
40848 export function UtxoLookupError_unknown_chain(): UtxoLookupError {
40849 if(!isWasmInitialized) {
40850 throw new Error("initializeWasm() must be awaited first!");
40852 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
40853 return nativeResponseValue;
40855 // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
40857 export function UtxoLookupError_unknown_tx(): UtxoLookupError {
40858 if(!isWasmInitialized) {
40859 throw new Error("initializeWasm() must be awaited first!");
40861 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
40862 return nativeResponseValue;
40864 // void UtxoResult_free(struct LDKUtxoResult this_ptr);
40866 export function UtxoResult_free(this_ptr: bigint): void {
40867 if(!isWasmInitialized) {
40868 throw new Error("initializeWasm() must be awaited first!");
40870 const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
40871 // debug statements here
40873 // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
40875 export function UtxoResult_clone_ptr(arg: bigint): bigint {
40876 if(!isWasmInitialized) {
40877 throw new Error("initializeWasm() must be awaited first!");
40879 const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
40880 return nativeResponseValue;
40882 // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
40884 export function UtxoResult_clone(orig: bigint): bigint {
40885 if(!isWasmInitialized) {
40886 throw new Error("initializeWasm() must be awaited first!");
40888 const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
40889 return nativeResponseValue;
40891 // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
40893 export function UtxoResult_sync(a: bigint): bigint {
40894 if(!isWasmInitialized) {
40895 throw new Error("initializeWasm() must be awaited first!");
40897 const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
40898 return nativeResponseValue;
40900 // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
40902 export function UtxoResult_async(a: bigint): bigint {
40903 if(!isWasmInitialized) {
40904 throw new Error("initializeWasm() must be awaited first!");
40906 const nativeResponseValue = wasm.TS_UtxoResult_async(a);
40907 return nativeResponseValue;
40909 // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
40911 export function UtxoLookup_free(this_ptr: bigint): void {
40912 if(!isWasmInitialized) {
40913 throw new Error("initializeWasm() must be awaited first!");
40915 const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
40916 // debug statements here
40918 // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
40920 export function UtxoFuture_free(this_obj: bigint): void {
40921 if(!isWasmInitialized) {
40922 throw new Error("initializeWasm() must be awaited first!");
40924 const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
40925 // debug statements here
40927 // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
40929 export function UtxoFuture_clone_ptr(arg: bigint): bigint {
40930 if(!isWasmInitialized) {
40931 throw new Error("initializeWasm() must be awaited first!");
40933 const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
40934 return nativeResponseValue;
40936 // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
40938 export function UtxoFuture_clone(orig: bigint): bigint {
40939 if(!isWasmInitialized) {
40940 throw new Error("initializeWasm() must be awaited first!");
40942 const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
40943 return nativeResponseValue;
40945 // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
40947 export function UtxoFuture_new(): bigint {
40948 if(!isWasmInitialized) {
40949 throw new Error("initializeWasm() must be awaited first!");
40951 const nativeResponseValue = wasm.TS_UtxoFuture_new();
40952 return nativeResponseValue;
40954 // void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
40956 export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
40957 if(!isWasmInitialized) {
40958 throw new Error("initializeWasm() must be awaited first!");
40960 const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
40961 // debug statements here
40963 // 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);
40965 export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
40966 if(!isWasmInitialized) {
40967 throw new Error("initializeWasm() must be awaited first!");
40969 const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
40970 // debug statements here
40972 // void NodeId_free(struct LDKNodeId this_obj);
40974 export function NodeId_free(this_obj: bigint): void {
40975 if(!isWasmInitialized) {
40976 throw new Error("initializeWasm() must be awaited first!");
40978 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
40979 // debug statements here
40981 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
40983 export function NodeId_clone_ptr(arg: bigint): bigint {
40984 if(!isWasmInitialized) {
40985 throw new Error("initializeWasm() must be awaited first!");
40987 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
40988 return nativeResponseValue;
40990 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
40992 export function NodeId_clone(orig: bigint): bigint {
40993 if(!isWasmInitialized) {
40994 throw new Error("initializeWasm() must be awaited first!");
40996 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
40997 return nativeResponseValue;
40999 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
41001 export function NodeId_from_pubkey(pubkey: number): bigint {
41002 if(!isWasmInitialized) {
41003 throw new Error("initializeWasm() must be awaited first!");
41005 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
41006 return nativeResponseValue;
41008 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
41010 export function NodeId_as_slice(this_arg: bigint): number {
41011 if(!isWasmInitialized) {
41012 throw new Error("initializeWasm() must be awaited first!");
41014 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
41015 return nativeResponseValue;
41017 // MUST_USE_RES struct LDKCResult_PublicKeyErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
41019 export function NodeId_as_pubkey(this_arg: bigint): bigint {
41020 if(!isWasmInitialized) {
41021 throw new Error("initializeWasm() must be awaited first!");
41023 const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
41024 return nativeResponseValue;
41026 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
41028 export function NodeId_hash(o: bigint): bigint {
41029 if(!isWasmInitialized) {
41030 throw new Error("initializeWasm() must be awaited first!");
41032 const nativeResponseValue = wasm.TS_NodeId_hash(o);
41033 return nativeResponseValue;
41035 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
41037 export function NodeId_write(obj: bigint): number {
41038 if(!isWasmInitialized) {
41039 throw new Error("initializeWasm() must be awaited first!");
41041 const nativeResponseValue = wasm.TS_NodeId_write(obj);
41042 return nativeResponseValue;
41044 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
41046 export function NodeId_read(ser: number): bigint {
41047 if(!isWasmInitialized) {
41048 throw new Error("initializeWasm() must be awaited first!");
41050 const nativeResponseValue = wasm.TS_NodeId_read(ser);
41051 return nativeResponseValue;
41053 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
41055 export function NetworkGraph_free(this_obj: bigint): void {
41056 if(!isWasmInitialized) {
41057 throw new Error("initializeWasm() must be awaited first!");
41059 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
41060 // debug statements here
41062 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
41064 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
41065 if(!isWasmInitialized) {
41066 throw new Error("initializeWasm() must be awaited first!");
41068 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
41069 // debug statements here
41071 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
41073 export function NetworkUpdate_free(this_ptr: bigint): void {
41074 if(!isWasmInitialized) {
41075 throw new Error("initializeWasm() must be awaited first!");
41077 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
41078 // debug statements here
41080 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
41082 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
41083 if(!isWasmInitialized) {
41084 throw new Error("initializeWasm() must be awaited first!");
41086 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
41087 return nativeResponseValue;
41089 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
41091 export function NetworkUpdate_clone(orig: bigint): bigint {
41092 if(!isWasmInitialized) {
41093 throw new Error("initializeWasm() must be awaited first!");
41095 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
41096 return nativeResponseValue;
41098 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
41100 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
41101 if(!isWasmInitialized) {
41102 throw new Error("initializeWasm() must be awaited first!");
41104 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
41105 return nativeResponseValue;
41107 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
41109 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
41110 if(!isWasmInitialized) {
41111 throw new Error("initializeWasm() must be awaited first!");
41113 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
41114 return nativeResponseValue;
41116 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
41118 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
41119 if(!isWasmInitialized) {
41120 throw new Error("initializeWasm() must be awaited first!");
41122 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
41123 return nativeResponseValue;
41125 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
41127 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
41128 if(!isWasmInitialized) {
41129 throw new Error("initializeWasm() must be awaited first!");
41131 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
41132 return nativeResponseValue;
41134 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
41136 export function NetworkUpdate_write(obj: bigint): number {
41137 if(!isWasmInitialized) {
41138 throw new Error("initializeWasm() must be awaited first!");
41140 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
41141 return nativeResponseValue;
41143 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
41145 export function NetworkUpdate_read(ser: number): bigint {
41146 if(!isWasmInitialized) {
41147 throw new Error("initializeWasm() must be awaited first!");
41149 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
41150 return nativeResponseValue;
41152 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
41154 export function P2PGossipSync_free(this_obj: bigint): void {
41155 if(!isWasmInitialized) {
41156 throw new Error("initializeWasm() must be awaited first!");
41158 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
41159 // debug statements here
41161 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
41163 export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
41164 if(!isWasmInitialized) {
41165 throw new Error("initializeWasm() must be awaited first!");
41167 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
41168 return nativeResponseValue;
41170 // void P2PGossipSync_add_utxo_lookup(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
41172 export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
41173 if(!isWasmInitialized) {
41174 throw new Error("initializeWasm() must be awaited first!");
41176 const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
41177 // debug statements here
41179 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
41181 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
41182 if(!isWasmInitialized) {
41183 throw new Error("initializeWasm() must be awaited first!");
41185 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
41186 // debug statements here
41188 // MUST_USE_RES struct LDKThirtyTwoBytes NetworkGraph_get_genesis_hash(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
41190 export function NetworkGraph_get_genesis_hash(this_arg: bigint): number {
41191 if(!isWasmInitialized) {
41192 throw new Error("initializeWasm() must be awaited first!");
41194 const nativeResponseValue = wasm.TS_NetworkGraph_get_genesis_hash(this_arg);
41195 return nativeResponseValue;
41197 // struct LDKCResult_NoneLightningErrorZ verify_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
41199 export function verify_node_announcement(msg: bigint): bigint {
41200 if(!isWasmInitialized) {
41201 throw new Error("initializeWasm() must be awaited first!");
41203 const nativeResponseValue = wasm.TS_verify_node_announcement(msg);
41204 return nativeResponseValue;
41206 // struct LDKCResult_NoneLightningErrorZ verify_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
41208 export function verify_channel_announcement(msg: bigint): bigint {
41209 if(!isWasmInitialized) {
41210 throw new Error("initializeWasm() must be awaited first!");
41212 const nativeResponseValue = wasm.TS_verify_channel_announcement(msg);
41213 return nativeResponseValue;
41215 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
41217 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
41218 if(!isWasmInitialized) {
41219 throw new Error("initializeWasm() must be awaited first!");
41221 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
41222 return nativeResponseValue;
41224 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
41226 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
41227 if(!isWasmInitialized) {
41228 throw new Error("initializeWasm() must be awaited first!");
41230 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
41231 return nativeResponseValue;
41233 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
41235 export function ChannelUpdateInfo_free(this_obj: bigint): void {
41236 if(!isWasmInitialized) {
41237 throw new Error("initializeWasm() must be awaited first!");
41239 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
41240 // debug statements here
41242 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41244 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
41245 if(!isWasmInitialized) {
41246 throw new Error("initializeWasm() must be awaited first!");
41248 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
41249 return nativeResponseValue;
41251 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
41253 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
41254 if(!isWasmInitialized) {
41255 throw new Error("initializeWasm() must be awaited first!");
41257 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
41258 // debug statements here
41260 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41262 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
41263 if(!isWasmInitialized) {
41264 throw new Error("initializeWasm() must be awaited first!");
41266 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
41267 return nativeResponseValue;
41269 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
41271 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
41272 if(!isWasmInitialized) {
41273 throw new Error("initializeWasm() must be awaited first!");
41275 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
41276 // debug statements here
41278 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41280 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
41281 if(!isWasmInitialized) {
41282 throw new Error("initializeWasm() must be awaited first!");
41284 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
41285 return nativeResponseValue;
41287 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
41289 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
41290 if(!isWasmInitialized) {
41291 throw new Error("initializeWasm() must be awaited first!");
41293 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
41294 // debug statements here
41296 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41298 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
41299 if(!isWasmInitialized) {
41300 throw new Error("initializeWasm() must be awaited first!");
41302 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
41303 return nativeResponseValue;
41305 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
41307 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
41308 if(!isWasmInitialized) {
41309 throw new Error("initializeWasm() must be awaited first!");
41311 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
41312 // debug statements here
41314 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41316 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
41317 if(!isWasmInitialized) {
41318 throw new Error("initializeWasm() must be awaited first!");
41320 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
41321 return nativeResponseValue;
41323 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
41325 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
41326 if(!isWasmInitialized) {
41327 throw new Error("initializeWasm() must be awaited first!");
41329 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
41330 // debug statements here
41332 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41334 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
41335 if(!isWasmInitialized) {
41336 throw new Error("initializeWasm() must be awaited first!");
41338 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
41339 return nativeResponseValue;
41341 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
41343 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
41344 if(!isWasmInitialized) {
41345 throw new Error("initializeWasm() must be awaited first!");
41347 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
41348 // debug statements here
41350 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
41352 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
41353 if(!isWasmInitialized) {
41354 throw new Error("initializeWasm() must be awaited first!");
41356 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
41357 return nativeResponseValue;
41359 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
41361 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
41362 if(!isWasmInitialized) {
41363 throw new Error("initializeWasm() must be awaited first!");
41365 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
41366 // debug statements here
41368 // 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);
41370 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 {
41371 if(!isWasmInitialized) {
41372 throw new Error("initializeWasm() must be awaited first!");
41374 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);
41375 return nativeResponseValue;
41377 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
41379 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
41380 if(!isWasmInitialized) {
41381 throw new Error("initializeWasm() must be awaited first!");
41383 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
41384 return nativeResponseValue;
41386 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
41388 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
41389 if(!isWasmInitialized) {
41390 throw new Error("initializeWasm() must be awaited first!");
41392 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
41393 return nativeResponseValue;
41395 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
41397 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
41398 if(!isWasmInitialized) {
41399 throw new Error("initializeWasm() must be awaited first!");
41401 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
41402 return nativeResponseValue;
41404 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
41406 export function ChannelUpdateInfo_write(obj: bigint): number {
41407 if(!isWasmInitialized) {
41408 throw new Error("initializeWasm() must be awaited first!");
41410 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
41411 return nativeResponseValue;
41413 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
41415 export function ChannelUpdateInfo_read(ser: number): bigint {
41416 if(!isWasmInitialized) {
41417 throw new Error("initializeWasm() must be awaited first!");
41419 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
41420 return nativeResponseValue;
41422 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
41424 export function ChannelInfo_free(this_obj: bigint): void {
41425 if(!isWasmInitialized) {
41426 throw new Error("initializeWasm() must be awaited first!");
41428 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
41429 // debug statements here
41431 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41433 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
41434 if(!isWasmInitialized) {
41435 throw new Error("initializeWasm() must be awaited first!");
41437 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
41438 return nativeResponseValue;
41440 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
41442 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
41443 if(!isWasmInitialized) {
41444 throw new Error("initializeWasm() must be awaited first!");
41446 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
41447 // debug statements here
41449 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41451 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
41452 if(!isWasmInitialized) {
41453 throw new Error("initializeWasm() must be awaited first!");
41455 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
41456 return nativeResponseValue;
41458 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
41460 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
41461 if(!isWasmInitialized) {
41462 throw new Error("initializeWasm() must be awaited first!");
41464 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
41465 // debug statements here
41467 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41469 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
41470 if(!isWasmInitialized) {
41471 throw new Error("initializeWasm() must be awaited first!");
41473 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
41474 return nativeResponseValue;
41476 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
41478 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
41479 if(!isWasmInitialized) {
41480 throw new Error("initializeWasm() must be awaited first!");
41482 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
41483 // debug statements here
41485 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41487 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
41488 if(!isWasmInitialized) {
41489 throw new Error("initializeWasm() must be awaited first!");
41491 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
41492 return nativeResponseValue;
41494 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
41496 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
41497 if(!isWasmInitialized) {
41498 throw new Error("initializeWasm() must be awaited first!");
41500 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
41501 // debug statements here
41503 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41505 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
41506 if(!isWasmInitialized) {
41507 throw new Error("initializeWasm() must be awaited first!");
41509 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
41510 return nativeResponseValue;
41512 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
41514 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
41515 if(!isWasmInitialized) {
41516 throw new Error("initializeWasm() must be awaited first!");
41518 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
41519 // debug statements here
41521 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41523 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
41524 if(!isWasmInitialized) {
41525 throw new Error("initializeWasm() must be awaited first!");
41527 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
41528 return nativeResponseValue;
41530 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
41532 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
41533 if(!isWasmInitialized) {
41534 throw new Error("initializeWasm() must be awaited first!");
41536 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
41537 // debug statements here
41539 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
41541 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
41542 if(!isWasmInitialized) {
41543 throw new Error("initializeWasm() must be awaited first!");
41545 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
41546 return nativeResponseValue;
41548 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
41550 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
41551 if(!isWasmInitialized) {
41552 throw new Error("initializeWasm() must be awaited first!");
41554 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
41555 // debug statements here
41557 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
41559 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
41560 if(!isWasmInitialized) {
41561 throw new Error("initializeWasm() must be awaited first!");
41563 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
41564 return nativeResponseValue;
41566 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
41568 export function ChannelInfo_clone(orig: bigint): bigint {
41569 if(!isWasmInitialized) {
41570 throw new Error("initializeWasm() must be awaited first!");
41572 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
41573 return nativeResponseValue;
41575 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
41577 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
41578 if(!isWasmInitialized) {
41579 throw new Error("initializeWasm() must be awaited first!");
41581 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
41582 return nativeResponseValue;
41584 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
41586 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
41587 if(!isWasmInitialized) {
41588 throw new Error("initializeWasm() must be awaited first!");
41590 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
41591 return nativeResponseValue;
41593 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
41595 export function ChannelInfo_write(obj: bigint): number {
41596 if(!isWasmInitialized) {
41597 throw new Error("initializeWasm() must be awaited first!");
41599 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
41600 return nativeResponseValue;
41602 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
41604 export function ChannelInfo_read(ser: number): bigint {
41605 if(!isWasmInitialized) {
41606 throw new Error("initializeWasm() must be awaited first!");
41608 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
41609 return nativeResponseValue;
41611 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
41613 export function DirectedChannelInfo_free(this_obj: bigint): void {
41614 if(!isWasmInitialized) {
41615 throw new Error("initializeWasm() must be awaited first!");
41617 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
41618 // debug statements here
41620 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
41622 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
41623 if(!isWasmInitialized) {
41624 throw new Error("initializeWasm() must be awaited first!");
41626 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
41627 return nativeResponseValue;
41629 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
41631 export function DirectedChannelInfo_clone(orig: bigint): bigint {
41632 if(!isWasmInitialized) {
41633 throw new Error("initializeWasm() must be awaited first!");
41635 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
41636 return nativeResponseValue;
41638 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
41640 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
41641 if(!isWasmInitialized) {
41642 throw new Error("initializeWasm() must be awaited first!");
41644 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
41645 return nativeResponseValue;
41647 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
41649 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
41650 if(!isWasmInitialized) {
41651 throw new Error("initializeWasm() must be awaited first!");
41653 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
41654 return nativeResponseValue;
41656 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
41658 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
41659 if(!isWasmInitialized) {
41660 throw new Error("initializeWasm() must be awaited first!");
41662 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
41663 return nativeResponseValue;
41665 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
41667 export function EffectiveCapacity_free(this_ptr: bigint): void {
41668 if(!isWasmInitialized) {
41669 throw new Error("initializeWasm() must be awaited first!");
41671 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
41672 // debug statements here
41674 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
41676 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
41677 if(!isWasmInitialized) {
41678 throw new Error("initializeWasm() must be awaited first!");
41680 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
41681 return nativeResponseValue;
41683 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
41685 export function EffectiveCapacity_clone(orig: bigint): bigint {
41686 if(!isWasmInitialized) {
41687 throw new Error("initializeWasm() must be awaited first!");
41689 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
41690 return nativeResponseValue;
41692 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
41694 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
41695 if(!isWasmInitialized) {
41696 throw new Error("initializeWasm() must be awaited first!");
41698 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
41699 return nativeResponseValue;
41701 // struct LDKEffectiveCapacity EffectiveCapacity_advertised_max_htlc(uint64_t amount_msat);
41703 export function EffectiveCapacity_advertised_max_htlc(amount_msat: bigint): bigint {
41704 if(!isWasmInitialized) {
41705 throw new Error("initializeWasm() must be awaited first!");
41707 const nativeResponseValue = wasm.TS_EffectiveCapacity_advertised_max_htlc(amount_msat);
41708 return nativeResponseValue;
41710 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
41712 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
41713 if(!isWasmInitialized) {
41714 throw new Error("initializeWasm() must be awaited first!");
41716 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
41717 return nativeResponseValue;
41719 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
41721 export function EffectiveCapacity_infinite(): bigint {
41722 if(!isWasmInitialized) {
41723 throw new Error("initializeWasm() must be awaited first!");
41725 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
41726 return nativeResponseValue;
41728 // struct LDKEffectiveCapacity EffectiveCapacity_hint_max_htlc(uint64_t amount_msat);
41730 export function EffectiveCapacity_hint_max_htlc(amount_msat: bigint): bigint {
41731 if(!isWasmInitialized) {
41732 throw new Error("initializeWasm() must be awaited first!");
41734 const nativeResponseValue = wasm.TS_EffectiveCapacity_hint_max_htlc(amount_msat);
41735 return nativeResponseValue;
41737 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
41739 export function EffectiveCapacity_unknown(): bigint {
41740 if(!isWasmInitialized) {
41741 throw new Error("initializeWasm() must be awaited first!");
41743 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
41744 return nativeResponseValue;
41746 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
41748 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
41749 if(!isWasmInitialized) {
41750 throw new Error("initializeWasm() must be awaited first!");
41752 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
41753 return nativeResponseValue;
41755 // void RoutingFees_free(struct LDKRoutingFees this_obj);
41757 export function RoutingFees_free(this_obj: bigint): void {
41758 if(!isWasmInitialized) {
41759 throw new Error("initializeWasm() must be awaited first!");
41761 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
41762 // debug statements here
41764 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
41766 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
41767 if(!isWasmInitialized) {
41768 throw new Error("initializeWasm() must be awaited first!");
41770 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
41771 return nativeResponseValue;
41773 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
41775 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
41776 if(!isWasmInitialized) {
41777 throw new Error("initializeWasm() must be awaited first!");
41779 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
41780 // debug statements here
41782 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
41784 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
41785 if(!isWasmInitialized) {
41786 throw new Error("initializeWasm() must be awaited first!");
41788 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
41789 return nativeResponseValue;
41791 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
41793 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
41794 if(!isWasmInitialized) {
41795 throw new Error("initializeWasm() must be awaited first!");
41797 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
41798 // debug statements here
41800 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
41802 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
41803 if(!isWasmInitialized) {
41804 throw new Error("initializeWasm() must be awaited first!");
41806 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
41807 return nativeResponseValue;
41809 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
41811 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
41812 if(!isWasmInitialized) {
41813 throw new Error("initializeWasm() must be awaited first!");
41815 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
41816 return nativeResponseValue;
41818 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
41820 export function RoutingFees_clone_ptr(arg: bigint): bigint {
41821 if(!isWasmInitialized) {
41822 throw new Error("initializeWasm() must be awaited first!");
41824 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
41825 return nativeResponseValue;
41827 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
41829 export function RoutingFees_clone(orig: bigint): bigint {
41830 if(!isWasmInitialized) {
41831 throw new Error("initializeWasm() must be awaited first!");
41833 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
41834 return nativeResponseValue;
41836 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
41838 export function RoutingFees_hash(o: bigint): bigint {
41839 if(!isWasmInitialized) {
41840 throw new Error("initializeWasm() must be awaited first!");
41842 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
41843 return nativeResponseValue;
41845 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
41847 export function RoutingFees_write(obj: bigint): number {
41848 if(!isWasmInitialized) {
41849 throw new Error("initializeWasm() must be awaited first!");
41851 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
41852 return nativeResponseValue;
41854 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
41856 export function RoutingFees_read(ser: number): bigint {
41857 if(!isWasmInitialized) {
41858 throw new Error("initializeWasm() must be awaited first!");
41860 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
41861 return nativeResponseValue;
41863 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
41865 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
41866 if(!isWasmInitialized) {
41867 throw new Error("initializeWasm() must be awaited first!");
41869 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
41870 // debug statements here
41872 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
41874 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
41875 if(!isWasmInitialized) {
41876 throw new Error("initializeWasm() must be awaited first!");
41878 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
41879 return nativeResponseValue;
41881 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
41883 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
41884 if(!isWasmInitialized) {
41885 throw new Error("initializeWasm() must be awaited first!");
41887 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
41888 // debug statements here
41890 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
41892 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
41893 if(!isWasmInitialized) {
41894 throw new Error("initializeWasm() must be awaited first!");
41896 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
41897 return nativeResponseValue;
41899 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
41901 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
41902 if(!isWasmInitialized) {
41903 throw new Error("initializeWasm() must be awaited first!");
41905 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
41906 // debug statements here
41908 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
41910 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
41911 if(!isWasmInitialized) {
41912 throw new Error("initializeWasm() must be awaited first!");
41914 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
41915 return nativeResponseValue;
41917 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
41919 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
41920 if(!isWasmInitialized) {
41921 throw new Error("initializeWasm() must be awaited first!");
41923 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
41924 // debug statements here
41926 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
41928 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
41929 if(!isWasmInitialized) {
41930 throw new Error("initializeWasm() must be awaited first!");
41932 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
41933 return nativeResponseValue;
41935 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
41937 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
41938 if(!isWasmInitialized) {
41939 throw new Error("initializeWasm() must be awaited first!");
41941 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
41942 // debug statements here
41944 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
41946 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
41947 if(!isWasmInitialized) {
41948 throw new Error("initializeWasm() must be awaited first!");
41950 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
41951 return nativeResponseValue;
41953 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
41955 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
41956 if(!isWasmInitialized) {
41957 throw new Error("initializeWasm() must be awaited first!");
41959 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
41960 // debug statements here
41962 // 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 LDKNodeAnnouncement announcement_message_arg);
41964 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, announcement_message_arg: bigint): bigint {
41965 if(!isWasmInitialized) {
41966 throw new Error("initializeWasm() must be awaited first!");
41968 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, announcement_message_arg);
41969 return nativeResponseValue;
41971 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
41973 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
41974 if(!isWasmInitialized) {
41975 throw new Error("initializeWasm() must be awaited first!");
41977 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
41978 return nativeResponseValue;
41980 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
41982 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
41983 if(!isWasmInitialized) {
41984 throw new Error("initializeWasm() must be awaited first!");
41986 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
41987 return nativeResponseValue;
41989 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
41991 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
41992 if(!isWasmInitialized) {
41993 throw new Error("initializeWasm() must be awaited first!");
41995 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
41996 return nativeResponseValue;
41998 // MUST_USE_RES struct LDKCVec_NetAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
42000 export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
42001 if(!isWasmInitialized) {
42002 throw new Error("initializeWasm() must be awaited first!");
42004 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
42005 return nativeResponseValue;
42007 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
42009 export function NodeAnnouncementInfo_write(obj: bigint): number {
42010 if(!isWasmInitialized) {
42011 throw new Error("initializeWasm() must be awaited first!");
42013 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
42014 return nativeResponseValue;
42016 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
42018 export function NodeAnnouncementInfo_read(ser: number): bigint {
42019 if(!isWasmInitialized) {
42020 throw new Error("initializeWasm() must be awaited first!");
42022 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
42023 return nativeResponseValue;
42025 // void NodeAlias_free(struct LDKNodeAlias this_obj);
42027 export function NodeAlias_free(this_obj: bigint): void {
42028 if(!isWasmInitialized) {
42029 throw new Error("initializeWasm() must be awaited first!");
42031 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
42032 // debug statements here
42034 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
42036 export function NodeAlias_get_a(this_ptr: bigint): number {
42037 if(!isWasmInitialized) {
42038 throw new Error("initializeWasm() must be awaited first!");
42040 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
42041 return nativeResponseValue;
42043 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42045 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
42046 if(!isWasmInitialized) {
42047 throw new Error("initializeWasm() must be awaited first!");
42049 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
42050 // debug statements here
42052 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
42054 export function NodeAlias_new(a_arg: number): bigint {
42055 if(!isWasmInitialized) {
42056 throw new Error("initializeWasm() must be awaited first!");
42058 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
42059 return nativeResponseValue;
42061 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
42063 export function NodeAlias_clone_ptr(arg: bigint): bigint {
42064 if(!isWasmInitialized) {
42065 throw new Error("initializeWasm() must be awaited first!");
42067 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
42068 return nativeResponseValue;
42070 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
42072 export function NodeAlias_clone(orig: bigint): bigint {
42073 if(!isWasmInitialized) {
42074 throw new Error("initializeWasm() must be awaited first!");
42076 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
42077 return nativeResponseValue;
42079 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
42081 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
42082 if(!isWasmInitialized) {
42083 throw new Error("initializeWasm() must be awaited first!");
42085 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
42086 return nativeResponseValue;
42088 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
42090 export function NodeAlias_write(obj: bigint): number {
42091 if(!isWasmInitialized) {
42092 throw new Error("initializeWasm() must be awaited first!");
42094 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
42095 return nativeResponseValue;
42097 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
42099 export function NodeAlias_read(ser: number): bigint {
42100 if(!isWasmInitialized) {
42101 throw new Error("initializeWasm() must be awaited first!");
42103 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
42104 return nativeResponseValue;
42106 // void NodeInfo_free(struct LDKNodeInfo this_obj);
42108 export function NodeInfo_free(this_obj: bigint): void {
42109 if(!isWasmInitialized) {
42110 throw new Error("initializeWasm() must be awaited first!");
42112 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
42113 // debug statements here
42115 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
42117 export function NodeInfo_get_channels(this_ptr: bigint): number {
42118 if(!isWasmInitialized) {
42119 throw new Error("initializeWasm() must be awaited first!");
42121 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
42122 return nativeResponseValue;
42124 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
42126 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
42127 if(!isWasmInitialized) {
42128 throw new Error("initializeWasm() must be awaited first!");
42130 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
42131 // debug statements here
42133 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
42135 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
42136 if(!isWasmInitialized) {
42137 throw new Error("initializeWasm() must be awaited first!");
42139 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
42140 return nativeResponseValue;
42142 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
42144 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
42145 if(!isWasmInitialized) {
42146 throw new Error("initializeWasm() must be awaited first!");
42148 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
42149 // debug statements here
42151 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
42153 export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
42154 if(!isWasmInitialized) {
42155 throw new Error("initializeWasm() must be awaited first!");
42157 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
42158 return nativeResponseValue;
42160 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
42162 export function NodeInfo_clone_ptr(arg: bigint): bigint {
42163 if(!isWasmInitialized) {
42164 throw new Error("initializeWasm() must be awaited first!");
42166 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
42167 return nativeResponseValue;
42169 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
42171 export function NodeInfo_clone(orig: bigint): bigint {
42172 if(!isWasmInitialized) {
42173 throw new Error("initializeWasm() must be awaited first!");
42175 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
42176 return nativeResponseValue;
42178 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
42180 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
42181 if(!isWasmInitialized) {
42182 throw new Error("initializeWasm() must be awaited first!");
42184 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
42185 return nativeResponseValue;
42187 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
42189 export function NodeInfo_write(obj: bigint): number {
42190 if(!isWasmInitialized) {
42191 throw new Error("initializeWasm() must be awaited first!");
42193 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
42194 return nativeResponseValue;
42196 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
42198 export function NodeInfo_read(ser: number): bigint {
42199 if(!isWasmInitialized) {
42200 throw new Error("initializeWasm() must be awaited first!");
42202 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
42203 return nativeResponseValue;
42205 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
42207 export function NetworkGraph_write(obj: bigint): number {
42208 if(!isWasmInitialized) {
42209 throw new Error("initializeWasm() must be awaited first!");
42211 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
42212 return nativeResponseValue;
42214 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
42216 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
42217 if(!isWasmInitialized) {
42218 throw new Error("initializeWasm() must be awaited first!");
42220 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
42221 return nativeResponseValue;
42223 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
42225 export function NetworkGraph_new(network: Network, logger: bigint): bigint {
42226 if(!isWasmInitialized) {
42227 throw new Error("initializeWasm() must be awaited first!");
42229 const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
42230 return nativeResponseValue;
42232 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
42234 export function NetworkGraph_read_only(this_arg: bigint): bigint {
42235 if(!isWasmInitialized) {
42236 throw new Error("initializeWasm() must be awaited first!");
42238 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
42239 return nativeResponseValue;
42241 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
42243 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
42244 if(!isWasmInitialized) {
42245 throw new Error("initializeWasm() must be awaited first!");
42247 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
42248 return nativeResponseValue;
42250 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
42252 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
42253 if(!isWasmInitialized) {
42254 throw new Error("initializeWasm() must be awaited first!");
42256 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
42257 // debug statements here
42259 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
42261 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
42262 if(!isWasmInitialized) {
42263 throw new Error("initializeWasm() must be awaited first!");
42265 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
42266 return nativeResponseValue;
42268 // 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);
42270 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
42271 if(!isWasmInitialized) {
42272 throw new Error("initializeWasm() must be awaited first!");
42274 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
42275 return nativeResponseValue;
42277 // 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);
42279 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
42280 if(!isWasmInitialized) {
42281 throw new Error("initializeWasm() must be awaited first!");
42283 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
42284 return nativeResponseValue;
42286 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement_no_lookup(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg);
42288 export function NetworkGraph_update_channel_from_announcement_no_lookup(this_arg: bigint, msg: bigint): bigint {
42289 if(!isWasmInitialized) {
42290 throw new Error("initializeWasm() must be awaited first!");
42292 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement_no_lookup(this_arg, msg);
42293 return nativeResponseValue;
42295 // 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);
42297 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
42298 if(!isWasmInitialized) {
42299 throw new Error("initializeWasm() must be awaited first!");
42301 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
42302 return nativeResponseValue;
42304 // 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);
42306 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 {
42307 if(!isWasmInitialized) {
42308 throw new Error("initializeWasm() must be awaited first!");
42310 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
42311 return nativeResponseValue;
42313 // void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
42315 export function NetworkGraph_channel_failed_permanent(this_arg: bigint, short_channel_id: bigint): void {
42316 if(!isWasmInitialized) {
42317 throw new Error("initializeWasm() must be awaited first!");
42319 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
42320 // debug statements here
42322 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
42324 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
42325 if(!isWasmInitialized) {
42326 throw new Error("initializeWasm() must be awaited first!");
42328 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
42329 // debug statements here
42331 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
42333 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
42334 if(!isWasmInitialized) {
42335 throw new Error("initializeWasm() must be awaited first!");
42337 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
42338 // debug statements here
42340 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
42342 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
42343 if(!isWasmInitialized) {
42344 throw new Error("initializeWasm() must be awaited first!");
42346 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
42347 return nativeResponseValue;
42349 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
42351 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
42352 if(!isWasmInitialized) {
42353 throw new Error("initializeWasm() must be awaited first!");
42355 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
42356 return nativeResponseValue;
42358 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
42360 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
42361 if(!isWasmInitialized) {
42362 throw new Error("initializeWasm() must be awaited first!");
42364 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
42365 return nativeResponseValue;
42367 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
42369 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
42370 if(!isWasmInitialized) {
42371 throw new Error("initializeWasm() must be awaited first!");
42373 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
42374 return nativeResponseValue;
42376 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
42378 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
42379 if(!isWasmInitialized) {
42380 throw new Error("initializeWasm() must be awaited first!");
42382 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
42383 return nativeResponseValue;
42385 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
42387 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
42388 if(!isWasmInitialized) {
42389 throw new Error("initializeWasm() must be awaited first!");
42391 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
42392 return nativeResponseValue;
42394 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
42396 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
42397 if(!isWasmInitialized) {
42398 throw new Error("initializeWasm() must be awaited first!");
42400 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
42401 return nativeResponseValue;
42403 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
42405 export function DefaultRouter_free(this_obj: bigint): void {
42406 if(!isWasmInitialized) {
42407 throw new Error("initializeWasm() must be awaited first!");
42409 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
42410 // debug statements here
42412 // 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, struct LDKProbabilisticScoringFeeParameters score_params);
42414 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint, score_params: bigint): bigint {
42415 if(!isWasmInitialized) {
42416 throw new Error("initializeWasm() must be awaited first!");
42418 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer, score_params);
42419 return nativeResponseValue;
42421 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
42423 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
42424 if(!isWasmInitialized) {
42425 throw new Error("initializeWasm() must be awaited first!");
42427 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
42428 return nativeResponseValue;
42430 // void Router_free(struct LDKRouter this_ptr);
42432 export function Router_free(this_ptr: bigint): void {
42433 if(!isWasmInitialized) {
42434 throw new Error("initializeWasm() must be awaited first!");
42436 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
42437 // debug statements here
42439 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
42441 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
42442 if(!isWasmInitialized) {
42443 throw new Error("initializeWasm() must be awaited first!");
42445 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
42446 // debug statements here
42448 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScore scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
42450 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
42451 if(!isWasmInitialized) {
42452 throw new Error("initializeWasm() must be awaited first!");
42454 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
42455 return nativeResponseValue;
42457 // struct LDKCVec_u8Z ScorerAccountingForInFlightHtlcs_write(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR obj);
42459 export function ScorerAccountingForInFlightHtlcs_write(obj: bigint): number {
42460 if(!isWasmInitialized) {
42461 throw new Error("initializeWasm() must be awaited first!");
42463 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_write(obj);
42464 return nativeResponseValue;
42466 // struct LDKScore ScorerAccountingForInFlightHtlcs_as_Score(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
42468 export function ScorerAccountingForInFlightHtlcs_as_Score(this_arg: bigint): bigint {
42469 if(!isWasmInitialized) {
42470 throw new Error("initializeWasm() must be awaited first!");
42472 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_Score(this_arg);
42473 return nativeResponseValue;
42475 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
42477 export function InFlightHtlcs_free(this_obj: bigint): void {
42478 if(!isWasmInitialized) {
42479 throw new Error("initializeWasm() must be awaited first!");
42481 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
42482 // debug statements here
42484 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
42486 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
42487 if(!isWasmInitialized) {
42488 throw new Error("initializeWasm() must be awaited first!");
42490 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
42491 return nativeResponseValue;
42493 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
42495 export function InFlightHtlcs_clone(orig: bigint): bigint {
42496 if(!isWasmInitialized) {
42497 throw new Error("initializeWasm() must be awaited first!");
42499 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
42500 return nativeResponseValue;
42502 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
42504 export function InFlightHtlcs_new(): bigint {
42505 if(!isWasmInitialized) {
42506 throw new Error("initializeWasm() must be awaited first!");
42508 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
42509 return nativeResponseValue;
42511 // void InFlightHtlcs_process_path(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, struct LDKPublicKey payer_node_id);
42513 export function InFlightHtlcs_process_path(this_arg: bigint, path: bigint, payer_node_id: number): void {
42514 if(!isWasmInitialized) {
42515 throw new Error("initializeWasm() must be awaited first!");
42517 const nativeResponseValue = wasm.TS_InFlightHtlcs_process_path(this_arg, path, payer_node_id);
42518 // debug statements here
42520 // void InFlightHtlcs_add_inflight_htlc(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, uint64_t channel_scid, uint64_t used_msat);
42522 export function InFlightHtlcs_add_inflight_htlc(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint, used_msat: bigint): void {
42523 if(!isWasmInitialized) {
42524 throw new Error("initializeWasm() must be awaited first!");
42526 const nativeResponseValue = wasm.TS_InFlightHtlcs_add_inflight_htlc(this_arg, source, target, channel_scid, used_msat);
42527 // debug statements here
42529 // 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);
42531 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
42532 if(!isWasmInitialized) {
42533 throw new Error("initializeWasm() must be awaited first!");
42535 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
42536 return nativeResponseValue;
42538 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
42540 export function InFlightHtlcs_write(obj: bigint): number {
42541 if(!isWasmInitialized) {
42542 throw new Error("initializeWasm() must be awaited first!");
42544 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
42545 return nativeResponseValue;
42547 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
42549 export function InFlightHtlcs_read(ser: number): bigint {
42550 if(!isWasmInitialized) {
42551 throw new Error("initializeWasm() must be awaited first!");
42553 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
42554 return nativeResponseValue;
42556 // void RouteHop_free(struct LDKRouteHop this_obj);
42558 export function RouteHop_free(this_obj: bigint): void {
42559 if(!isWasmInitialized) {
42560 throw new Error("initializeWasm() must be awaited first!");
42562 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
42563 // debug statements here
42565 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
42567 export function RouteHop_get_pubkey(this_ptr: bigint): number {
42568 if(!isWasmInitialized) {
42569 throw new Error("initializeWasm() must be awaited first!");
42571 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
42572 return nativeResponseValue;
42574 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
42576 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
42577 if(!isWasmInitialized) {
42578 throw new Error("initializeWasm() must be awaited first!");
42580 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
42581 // debug statements here
42583 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
42585 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
42586 if(!isWasmInitialized) {
42587 throw new Error("initializeWasm() must be awaited first!");
42589 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
42590 return nativeResponseValue;
42592 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
42594 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
42595 if(!isWasmInitialized) {
42596 throw new Error("initializeWasm() must be awaited first!");
42598 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
42599 // debug statements here
42601 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
42603 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
42604 if(!isWasmInitialized) {
42605 throw new Error("initializeWasm() must be awaited first!");
42607 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
42608 return nativeResponseValue;
42610 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
42612 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
42613 if(!isWasmInitialized) {
42614 throw new Error("initializeWasm() must be awaited first!");
42616 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
42617 // debug statements here
42619 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
42621 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
42622 if(!isWasmInitialized) {
42623 throw new Error("initializeWasm() must be awaited first!");
42625 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
42626 return nativeResponseValue;
42628 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
42630 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
42631 if(!isWasmInitialized) {
42632 throw new Error("initializeWasm() must be awaited first!");
42634 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
42635 // debug statements here
42637 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
42639 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
42640 if(!isWasmInitialized) {
42641 throw new Error("initializeWasm() must be awaited first!");
42643 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
42644 return nativeResponseValue;
42646 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
42648 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
42649 if(!isWasmInitialized) {
42650 throw new Error("initializeWasm() must be awaited first!");
42652 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
42653 // debug statements here
42655 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
42657 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
42658 if(!isWasmInitialized) {
42659 throw new Error("initializeWasm() must be awaited first!");
42661 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
42662 return nativeResponseValue;
42664 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
42666 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
42667 if(!isWasmInitialized) {
42668 throw new Error("initializeWasm() must be awaited first!");
42670 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
42671 // debug statements here
42673 // 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);
42675 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 {
42676 if(!isWasmInitialized) {
42677 throw new Error("initializeWasm() must be awaited first!");
42679 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);
42680 return nativeResponseValue;
42682 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
42684 export function RouteHop_clone_ptr(arg: bigint): bigint {
42685 if(!isWasmInitialized) {
42686 throw new Error("initializeWasm() must be awaited first!");
42688 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
42689 return nativeResponseValue;
42691 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
42693 export function RouteHop_clone(orig: bigint): bigint {
42694 if(!isWasmInitialized) {
42695 throw new Error("initializeWasm() must be awaited first!");
42697 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
42698 return nativeResponseValue;
42700 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
42702 export function RouteHop_hash(o: bigint): bigint {
42703 if(!isWasmInitialized) {
42704 throw new Error("initializeWasm() must be awaited first!");
42706 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
42707 return nativeResponseValue;
42709 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
42711 export function RouteHop_eq(a: bigint, b: bigint): boolean {
42712 if(!isWasmInitialized) {
42713 throw new Error("initializeWasm() must be awaited first!");
42715 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
42716 return nativeResponseValue;
42718 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
42720 export function RouteHop_write(obj: bigint): number {
42721 if(!isWasmInitialized) {
42722 throw new Error("initializeWasm() must be awaited first!");
42724 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
42725 return nativeResponseValue;
42727 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
42729 export function RouteHop_read(ser: number): bigint {
42730 if(!isWasmInitialized) {
42731 throw new Error("initializeWasm() must be awaited first!");
42733 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
42734 return nativeResponseValue;
42736 // void BlindedTail_free(struct LDKBlindedTail this_obj);
42738 export function BlindedTail_free(this_obj: bigint): void {
42739 if(!isWasmInitialized) {
42740 throw new Error("initializeWasm() must be awaited first!");
42742 const nativeResponseValue = wasm.TS_BlindedTail_free(this_obj);
42743 // debug statements here
42745 // struct LDKCVec_BlindedHopZ BlindedTail_get_hops(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
42747 export function BlindedTail_get_hops(this_ptr: bigint): number {
42748 if(!isWasmInitialized) {
42749 throw new Error("initializeWasm() must be awaited first!");
42751 const nativeResponseValue = wasm.TS_BlindedTail_get_hops(this_ptr);
42752 return nativeResponseValue;
42754 // void BlindedTail_set_hops(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
42756 export function BlindedTail_set_hops(this_ptr: bigint, val: number): void {
42757 if(!isWasmInitialized) {
42758 throw new Error("initializeWasm() must be awaited first!");
42760 const nativeResponseValue = wasm.TS_BlindedTail_set_hops(this_ptr, val);
42761 // debug statements here
42763 // struct LDKPublicKey BlindedTail_get_blinding_point(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
42765 export function BlindedTail_get_blinding_point(this_ptr: bigint): number {
42766 if(!isWasmInitialized) {
42767 throw new Error("initializeWasm() must be awaited first!");
42769 const nativeResponseValue = wasm.TS_BlindedTail_get_blinding_point(this_ptr);
42770 return nativeResponseValue;
42772 // void BlindedTail_set_blinding_point(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKPublicKey val);
42774 export function BlindedTail_set_blinding_point(this_ptr: bigint, val: number): void {
42775 if(!isWasmInitialized) {
42776 throw new Error("initializeWasm() must be awaited first!");
42778 const nativeResponseValue = wasm.TS_BlindedTail_set_blinding_point(this_ptr, val);
42779 // debug statements here
42781 // uint32_t BlindedTail_get_excess_final_cltv_expiry_delta(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
42783 export function BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr: bigint): number {
42784 if(!isWasmInitialized) {
42785 throw new Error("initializeWasm() must be awaited first!");
42787 const nativeResponseValue = wasm.TS_BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr);
42788 return nativeResponseValue;
42790 // void BlindedTail_set_excess_final_cltv_expiry_delta(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint32_t val);
42792 export function BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
42793 if(!isWasmInitialized) {
42794 throw new Error("initializeWasm() must be awaited first!");
42796 const nativeResponseValue = wasm.TS_BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr, val);
42797 // debug statements here
42799 // uint64_t BlindedTail_get_final_value_msat(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
42801 export function BlindedTail_get_final_value_msat(this_ptr: bigint): bigint {
42802 if(!isWasmInitialized) {
42803 throw new Error("initializeWasm() must be awaited first!");
42805 const nativeResponseValue = wasm.TS_BlindedTail_get_final_value_msat(this_ptr);
42806 return nativeResponseValue;
42808 // void BlindedTail_set_final_value_msat(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint64_t val);
42810 export function BlindedTail_set_final_value_msat(this_ptr: bigint, val: bigint): void {
42811 if(!isWasmInitialized) {
42812 throw new Error("initializeWasm() must be awaited first!");
42814 const nativeResponseValue = wasm.TS_BlindedTail_set_final_value_msat(this_ptr, val);
42815 // debug statements here
42817 // MUST_USE_RES struct LDKBlindedTail BlindedTail_new(struct LDKCVec_BlindedHopZ hops_arg, struct LDKPublicKey blinding_point_arg, uint32_t excess_final_cltv_expiry_delta_arg, uint64_t final_value_msat_arg);
42819 export function BlindedTail_new(hops_arg: number, blinding_point_arg: number, excess_final_cltv_expiry_delta_arg: number, final_value_msat_arg: bigint): bigint {
42820 if(!isWasmInitialized) {
42821 throw new Error("initializeWasm() must be awaited first!");
42823 const nativeResponseValue = wasm.TS_BlindedTail_new(hops_arg, blinding_point_arg, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
42824 return nativeResponseValue;
42826 // uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg);
42828 export function BlindedTail_clone_ptr(arg: bigint): bigint {
42829 if(!isWasmInitialized) {
42830 throw new Error("initializeWasm() must be awaited first!");
42832 const nativeResponseValue = wasm.TS_BlindedTail_clone_ptr(arg);
42833 return nativeResponseValue;
42835 // struct LDKBlindedTail BlindedTail_clone(const struct LDKBlindedTail *NONNULL_PTR orig);
42837 export function BlindedTail_clone(orig: bigint): bigint {
42838 if(!isWasmInitialized) {
42839 throw new Error("initializeWasm() must be awaited first!");
42841 const nativeResponseValue = wasm.TS_BlindedTail_clone(orig);
42842 return nativeResponseValue;
42844 // uint64_t BlindedTail_hash(const struct LDKBlindedTail *NONNULL_PTR o);
42846 export function BlindedTail_hash(o: bigint): bigint {
42847 if(!isWasmInitialized) {
42848 throw new Error("initializeWasm() must be awaited first!");
42850 const nativeResponseValue = wasm.TS_BlindedTail_hash(o);
42851 return nativeResponseValue;
42853 // bool BlindedTail_eq(const struct LDKBlindedTail *NONNULL_PTR a, const struct LDKBlindedTail *NONNULL_PTR b);
42855 export function BlindedTail_eq(a: bigint, b: bigint): boolean {
42856 if(!isWasmInitialized) {
42857 throw new Error("initializeWasm() must be awaited first!");
42859 const nativeResponseValue = wasm.TS_BlindedTail_eq(a, b);
42860 return nativeResponseValue;
42862 // struct LDKCVec_u8Z BlindedTail_write(const struct LDKBlindedTail *NONNULL_PTR obj);
42864 export function BlindedTail_write(obj: bigint): number {
42865 if(!isWasmInitialized) {
42866 throw new Error("initializeWasm() must be awaited first!");
42868 const nativeResponseValue = wasm.TS_BlindedTail_write(obj);
42869 return nativeResponseValue;
42871 // struct LDKCResult_BlindedTailDecodeErrorZ BlindedTail_read(struct LDKu8slice ser);
42873 export function BlindedTail_read(ser: number): bigint {
42874 if(!isWasmInitialized) {
42875 throw new Error("initializeWasm() must be awaited first!");
42877 const nativeResponseValue = wasm.TS_BlindedTail_read(ser);
42878 return nativeResponseValue;
42880 // void Path_free(struct LDKPath this_obj);
42882 export function Path_free(this_obj: bigint): void {
42883 if(!isWasmInitialized) {
42884 throw new Error("initializeWasm() must be awaited first!");
42886 const nativeResponseValue = wasm.TS_Path_free(this_obj);
42887 // debug statements here
42889 // struct LDKCVec_RouteHopZ Path_get_hops(const struct LDKPath *NONNULL_PTR this_ptr);
42891 export function Path_get_hops(this_ptr: bigint): number {
42892 if(!isWasmInitialized) {
42893 throw new Error("initializeWasm() must be awaited first!");
42895 const nativeResponseValue = wasm.TS_Path_get_hops(this_ptr);
42896 return nativeResponseValue;
42898 // void Path_set_hops(struct LDKPath *NONNULL_PTR this_ptr, struct LDKCVec_RouteHopZ val);
42900 export function Path_set_hops(this_ptr: bigint, val: number): void {
42901 if(!isWasmInitialized) {
42902 throw new Error("initializeWasm() must be awaited first!");
42904 const nativeResponseValue = wasm.TS_Path_set_hops(this_ptr, val);
42905 // debug statements here
42907 // struct LDKBlindedTail Path_get_blinded_tail(const struct LDKPath *NONNULL_PTR this_ptr);
42909 export function Path_get_blinded_tail(this_ptr: bigint): bigint {
42910 if(!isWasmInitialized) {
42911 throw new Error("initializeWasm() must be awaited first!");
42913 const nativeResponseValue = wasm.TS_Path_get_blinded_tail(this_ptr);
42914 return nativeResponseValue;
42916 // void Path_set_blinded_tail(struct LDKPath *NONNULL_PTR this_ptr, struct LDKBlindedTail val);
42918 export function Path_set_blinded_tail(this_ptr: bigint, val: bigint): void {
42919 if(!isWasmInitialized) {
42920 throw new Error("initializeWasm() must be awaited first!");
42922 const nativeResponseValue = wasm.TS_Path_set_blinded_tail(this_ptr, val);
42923 // debug statements here
42925 // MUST_USE_RES struct LDKPath Path_new(struct LDKCVec_RouteHopZ hops_arg, struct LDKBlindedTail blinded_tail_arg);
42927 export function Path_new(hops_arg: number, blinded_tail_arg: bigint): bigint {
42928 if(!isWasmInitialized) {
42929 throw new Error("initializeWasm() must be awaited first!");
42931 const nativeResponseValue = wasm.TS_Path_new(hops_arg, blinded_tail_arg);
42932 return nativeResponseValue;
42934 // uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg);
42936 export function Path_clone_ptr(arg: bigint): bigint {
42937 if(!isWasmInitialized) {
42938 throw new Error("initializeWasm() must be awaited first!");
42940 const nativeResponseValue = wasm.TS_Path_clone_ptr(arg);
42941 return nativeResponseValue;
42943 // struct LDKPath Path_clone(const struct LDKPath *NONNULL_PTR orig);
42945 export function Path_clone(orig: bigint): bigint {
42946 if(!isWasmInitialized) {
42947 throw new Error("initializeWasm() must be awaited first!");
42949 const nativeResponseValue = wasm.TS_Path_clone(orig);
42950 return nativeResponseValue;
42952 // uint64_t Path_hash(const struct LDKPath *NONNULL_PTR o);
42954 export function Path_hash(o: bigint): bigint {
42955 if(!isWasmInitialized) {
42956 throw new Error("initializeWasm() must be awaited first!");
42958 const nativeResponseValue = wasm.TS_Path_hash(o);
42959 return nativeResponseValue;
42961 // bool Path_eq(const struct LDKPath *NONNULL_PTR a, const struct LDKPath *NONNULL_PTR b);
42963 export function Path_eq(a: bigint, b: bigint): boolean {
42964 if(!isWasmInitialized) {
42965 throw new Error("initializeWasm() must be awaited first!");
42967 const nativeResponseValue = wasm.TS_Path_eq(a, b);
42968 return nativeResponseValue;
42970 // MUST_USE_RES uint64_t Path_fee_msat(const struct LDKPath *NONNULL_PTR this_arg);
42972 export function Path_fee_msat(this_arg: bigint): bigint {
42973 if(!isWasmInitialized) {
42974 throw new Error("initializeWasm() must be awaited first!");
42976 const nativeResponseValue = wasm.TS_Path_fee_msat(this_arg);
42977 return nativeResponseValue;
42979 // MUST_USE_RES uint64_t Path_final_value_msat(const struct LDKPath *NONNULL_PTR this_arg);
42981 export function Path_final_value_msat(this_arg: bigint): bigint {
42982 if(!isWasmInitialized) {
42983 throw new Error("initializeWasm() must be awaited first!");
42985 const nativeResponseValue = wasm.TS_Path_final_value_msat(this_arg);
42986 return nativeResponseValue;
42988 // MUST_USE_RES struct LDKCOption_u32Z Path_final_cltv_expiry_delta(const struct LDKPath *NONNULL_PTR this_arg);
42990 export function Path_final_cltv_expiry_delta(this_arg: bigint): bigint {
42991 if(!isWasmInitialized) {
42992 throw new Error("initializeWasm() must be awaited first!");
42994 const nativeResponseValue = wasm.TS_Path_final_cltv_expiry_delta(this_arg);
42995 return nativeResponseValue;
42997 // void Route_free(struct LDKRoute this_obj);
42999 export function Route_free(this_obj: bigint): void {
43000 if(!isWasmInitialized) {
43001 throw new Error("initializeWasm() must be awaited first!");
43003 const nativeResponseValue = wasm.TS_Route_free(this_obj);
43004 // debug statements here
43006 // struct LDKCVec_PathZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
43008 export function Route_get_paths(this_ptr: bigint): number {
43009 if(!isWasmInitialized) {
43010 throw new Error("initializeWasm() must be awaited first!");
43012 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
43013 return nativeResponseValue;
43015 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_PathZ val);
43017 export function Route_set_paths(this_ptr: bigint, val: number): void {
43018 if(!isWasmInitialized) {
43019 throw new Error("initializeWasm() must be awaited first!");
43021 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
43022 // debug statements here
43024 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
43026 export function Route_get_payment_params(this_ptr: bigint): bigint {
43027 if(!isWasmInitialized) {
43028 throw new Error("initializeWasm() must be awaited first!");
43030 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
43031 return nativeResponseValue;
43033 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
43035 export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
43036 if(!isWasmInitialized) {
43037 throw new Error("initializeWasm() must be awaited first!");
43039 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
43040 // debug statements here
43042 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKPaymentParameters payment_params_arg);
43044 export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
43045 if(!isWasmInitialized) {
43046 throw new Error("initializeWasm() must be awaited first!");
43048 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
43049 return nativeResponseValue;
43051 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
43053 export function Route_clone_ptr(arg: bigint): bigint {
43054 if(!isWasmInitialized) {
43055 throw new Error("initializeWasm() must be awaited first!");
43057 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
43058 return nativeResponseValue;
43060 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
43062 export function Route_clone(orig: bigint): bigint {
43063 if(!isWasmInitialized) {
43064 throw new Error("initializeWasm() must be awaited first!");
43066 const nativeResponseValue = wasm.TS_Route_clone(orig);
43067 return nativeResponseValue;
43069 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
43071 export function Route_hash(o: bigint): bigint {
43072 if(!isWasmInitialized) {
43073 throw new Error("initializeWasm() must be awaited first!");
43075 const nativeResponseValue = wasm.TS_Route_hash(o);
43076 return nativeResponseValue;
43078 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
43080 export function Route_eq(a: bigint, b: bigint): boolean {
43081 if(!isWasmInitialized) {
43082 throw new Error("initializeWasm() must be awaited first!");
43084 const nativeResponseValue = wasm.TS_Route_eq(a, b);
43085 return nativeResponseValue;
43087 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
43089 export function Route_get_total_fees(this_arg: bigint): bigint {
43090 if(!isWasmInitialized) {
43091 throw new Error("initializeWasm() must be awaited first!");
43093 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
43094 return nativeResponseValue;
43096 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
43098 export function Route_get_total_amount(this_arg: bigint): bigint {
43099 if(!isWasmInitialized) {
43100 throw new Error("initializeWasm() must be awaited first!");
43102 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
43103 return nativeResponseValue;
43105 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
43107 export function Route_write(obj: bigint): number {
43108 if(!isWasmInitialized) {
43109 throw new Error("initializeWasm() must be awaited first!");
43111 const nativeResponseValue = wasm.TS_Route_write(obj);
43112 return nativeResponseValue;
43114 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
43116 export function Route_read(ser: number): bigint {
43117 if(!isWasmInitialized) {
43118 throw new Error("initializeWasm() must be awaited first!");
43120 const nativeResponseValue = wasm.TS_Route_read(ser);
43121 return nativeResponseValue;
43123 // void RouteParameters_free(struct LDKRouteParameters this_obj);
43125 export function RouteParameters_free(this_obj: bigint): void {
43126 if(!isWasmInitialized) {
43127 throw new Error("initializeWasm() must be awaited first!");
43129 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
43130 // debug statements here
43132 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
43134 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
43135 if(!isWasmInitialized) {
43136 throw new Error("initializeWasm() must be awaited first!");
43138 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
43139 return nativeResponseValue;
43141 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
43143 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
43144 if(!isWasmInitialized) {
43145 throw new Error("initializeWasm() must be awaited first!");
43147 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
43148 // debug statements here
43150 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
43152 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
43153 if(!isWasmInitialized) {
43154 throw new Error("initializeWasm() must be awaited first!");
43156 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
43157 return nativeResponseValue;
43159 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
43161 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
43162 if(!isWasmInitialized) {
43163 throw new Error("initializeWasm() must be awaited first!");
43165 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
43166 // debug statements here
43168 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg);
43170 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint): bigint {
43171 if(!isWasmInitialized) {
43172 throw new Error("initializeWasm() must be awaited first!");
43174 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg);
43175 return nativeResponseValue;
43177 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
43179 export function RouteParameters_clone_ptr(arg: bigint): bigint {
43180 if(!isWasmInitialized) {
43181 throw new Error("initializeWasm() must be awaited first!");
43183 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
43184 return nativeResponseValue;
43186 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
43188 export function RouteParameters_clone(orig: bigint): bigint {
43189 if(!isWasmInitialized) {
43190 throw new Error("initializeWasm() must be awaited first!");
43192 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
43193 return nativeResponseValue;
43195 // bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
43197 export function RouteParameters_eq(a: bigint, b: bigint): boolean {
43198 if(!isWasmInitialized) {
43199 throw new Error("initializeWasm() must be awaited first!");
43201 const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
43202 return nativeResponseValue;
43204 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
43206 export function RouteParameters_write(obj: bigint): number {
43207 if(!isWasmInitialized) {
43208 throw new Error("initializeWasm() must be awaited first!");
43210 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
43211 return nativeResponseValue;
43213 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
43215 export function RouteParameters_read(ser: number): bigint {
43216 if(!isWasmInitialized) {
43217 throw new Error("initializeWasm() must be awaited first!");
43219 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
43220 return nativeResponseValue;
43222 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
43224 export function PaymentParameters_free(this_obj: bigint): void {
43225 if(!isWasmInitialized) {
43226 throw new Error("initializeWasm() must be awaited first!");
43228 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
43229 // debug statements here
43231 // struct LDKPayee PaymentParameters_get_payee(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
43233 export function PaymentParameters_get_payee(this_ptr: bigint): bigint {
43234 if(!isWasmInitialized) {
43235 throw new Error("initializeWasm() must be awaited first!");
43237 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee(this_ptr);
43238 return nativeResponseValue;
43240 // void PaymentParameters_set_payee(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
43242 export function PaymentParameters_set_payee(this_ptr: bigint, val: bigint): void {
43243 if(!isWasmInitialized) {
43244 throw new Error("initializeWasm() must be awaited first!");
43246 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee(this_ptr, val);
43247 // debug statements here
43249 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
43251 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
43252 if(!isWasmInitialized) {
43253 throw new Error("initializeWasm() must be awaited first!");
43255 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
43256 return nativeResponseValue;
43258 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
43260 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
43261 if(!isWasmInitialized) {
43262 throw new Error("initializeWasm() must be awaited first!");
43264 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
43265 // debug statements here
43267 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
43269 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
43270 if(!isWasmInitialized) {
43271 throw new Error("initializeWasm() must be awaited first!");
43273 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
43274 return nativeResponseValue;
43276 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
43278 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
43279 if(!isWasmInitialized) {
43280 throw new Error("initializeWasm() must be awaited first!");
43282 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
43283 // debug statements here
43285 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
43287 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
43288 if(!isWasmInitialized) {
43289 throw new Error("initializeWasm() must be awaited first!");
43291 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
43292 return nativeResponseValue;
43294 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
43296 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
43297 if(!isWasmInitialized) {
43298 throw new Error("initializeWasm() must be awaited first!");
43300 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
43301 // debug statements here
43303 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
43305 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
43306 if(!isWasmInitialized) {
43307 throw new Error("initializeWasm() must be awaited first!");
43309 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
43310 return nativeResponseValue;
43312 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
43314 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
43315 if(!isWasmInitialized) {
43316 throw new Error("initializeWasm() must be awaited first!");
43318 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
43319 // debug statements here
43321 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
43323 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
43324 if(!isWasmInitialized) {
43325 throw new Error("initializeWasm() must be awaited first!");
43327 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
43328 return nativeResponseValue;
43330 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
43332 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
43333 if(!isWasmInitialized) {
43334 throw new Error("initializeWasm() must be awaited first!");
43336 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
43337 // debug statements here
43339 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPayee payee_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);
43341 export function PaymentParameters_new(payee_arg: bigint, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number): bigint {
43342 if(!isWasmInitialized) {
43343 throw new Error("initializeWasm() must be awaited first!");
43345 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_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);
43346 return nativeResponseValue;
43348 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
43350 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
43351 if(!isWasmInitialized) {
43352 throw new Error("initializeWasm() must be awaited first!");
43354 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
43355 return nativeResponseValue;
43357 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
43359 export function PaymentParameters_clone(orig: bigint): bigint {
43360 if(!isWasmInitialized) {
43361 throw new Error("initializeWasm() must be awaited first!");
43363 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
43364 return nativeResponseValue;
43366 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
43368 export function PaymentParameters_hash(o: bigint): bigint {
43369 if(!isWasmInitialized) {
43370 throw new Error("initializeWasm() must be awaited first!");
43372 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
43373 return nativeResponseValue;
43375 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
43377 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
43378 if(!isWasmInitialized) {
43379 throw new Error("initializeWasm() must be awaited first!");
43381 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
43382 return nativeResponseValue;
43384 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
43386 export function PaymentParameters_write(obj: bigint): number {
43387 if(!isWasmInitialized) {
43388 throw new Error("initializeWasm() must be awaited first!");
43390 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
43391 return nativeResponseValue;
43393 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
43395 export function PaymentParameters_read(ser: number, arg: number): bigint {
43396 if(!isWasmInitialized) {
43397 throw new Error("initializeWasm() must be awaited first!");
43399 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
43400 return nativeResponseValue;
43402 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
43404 export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
43405 if(!isWasmInitialized) {
43406 throw new Error("initializeWasm() must be awaited first!");
43408 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
43409 return nativeResponseValue;
43411 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta, bool allow_mpp);
43413 export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number, allow_mpp: boolean): bigint {
43414 if(!isWasmInitialized) {
43415 throw new Error("initializeWasm() must be awaited first!");
43417 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta, allow_mpp);
43418 return nativeResponseValue;
43420 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_bolt12_invoice(const struct LDKBolt12Invoice *NONNULL_PTR invoice);
43422 export function PaymentParameters_from_bolt12_invoice(invoice: bigint): bigint {
43423 if(!isWasmInitialized) {
43424 throw new Error("initializeWasm() must be awaited first!");
43426 const nativeResponseValue = wasm.TS_PaymentParameters_from_bolt12_invoice(invoice);
43427 return nativeResponseValue;
43429 // void Payee_free(struct LDKPayee this_ptr);
43431 export function Payee_free(this_ptr: bigint): void {
43432 if(!isWasmInitialized) {
43433 throw new Error("initializeWasm() must be awaited first!");
43435 const nativeResponseValue = wasm.TS_Payee_free(this_ptr);
43436 // debug statements here
43438 // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
43440 export function Payee_clone_ptr(arg: bigint): bigint {
43441 if(!isWasmInitialized) {
43442 throw new Error("initializeWasm() must be awaited first!");
43444 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
43445 return nativeResponseValue;
43447 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
43449 export function Payee_clone(orig: bigint): bigint {
43450 if(!isWasmInitialized) {
43451 throw new Error("initializeWasm() must be awaited first!");
43453 const nativeResponseValue = wasm.TS_Payee_clone(orig);
43454 return nativeResponseValue;
43456 // struct LDKPayee Payee_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints, struct LDKBolt12InvoiceFeatures features);
43458 export function Payee_blinded(route_hints: number, features: bigint): bigint {
43459 if(!isWasmInitialized) {
43460 throw new Error("initializeWasm() must be awaited first!");
43462 const nativeResponseValue = wasm.TS_Payee_blinded(route_hints, features);
43463 return nativeResponseValue;
43465 // struct LDKPayee Payee_clear(struct LDKPublicKey node_id, struct LDKCVec_RouteHintZ route_hints, struct LDKBolt11InvoiceFeatures features, uint32_t final_cltv_expiry_delta);
43467 export function Payee_clear(node_id: number, route_hints: number, features: bigint, final_cltv_expiry_delta: number): bigint {
43468 if(!isWasmInitialized) {
43469 throw new Error("initializeWasm() must be awaited first!");
43471 const nativeResponseValue = wasm.TS_Payee_clear(node_id, route_hints, features, final_cltv_expiry_delta);
43472 return nativeResponseValue;
43474 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
43476 export function Payee_hash(o: bigint): bigint {
43477 if(!isWasmInitialized) {
43478 throw new Error("initializeWasm() must be awaited first!");
43480 const nativeResponseValue = wasm.TS_Payee_hash(o);
43481 return nativeResponseValue;
43483 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
43485 export function Payee_eq(a: bigint, b: bigint): boolean {
43486 if(!isWasmInitialized) {
43487 throw new Error("initializeWasm() must be awaited first!");
43489 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
43490 return nativeResponseValue;
43492 // void RouteHint_free(struct LDKRouteHint this_obj);
43494 export function RouteHint_free(this_obj: bigint): void {
43495 if(!isWasmInitialized) {
43496 throw new Error("initializeWasm() must be awaited first!");
43498 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
43499 // debug statements here
43501 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
43503 export function RouteHint_get_a(this_ptr: bigint): number {
43504 if(!isWasmInitialized) {
43505 throw new Error("initializeWasm() must be awaited first!");
43507 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
43508 return nativeResponseValue;
43510 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
43512 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
43513 if(!isWasmInitialized) {
43514 throw new Error("initializeWasm() must be awaited first!");
43516 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
43517 // debug statements here
43519 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
43521 export function RouteHint_new(a_arg: number): bigint {
43522 if(!isWasmInitialized) {
43523 throw new Error("initializeWasm() must be awaited first!");
43525 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
43526 return nativeResponseValue;
43528 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
43530 export function RouteHint_clone_ptr(arg: bigint): bigint {
43531 if(!isWasmInitialized) {
43532 throw new Error("initializeWasm() must be awaited first!");
43534 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
43535 return nativeResponseValue;
43537 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
43539 export function RouteHint_clone(orig: bigint): bigint {
43540 if(!isWasmInitialized) {
43541 throw new Error("initializeWasm() must be awaited first!");
43543 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
43544 return nativeResponseValue;
43546 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
43548 export function RouteHint_hash(o: bigint): bigint {
43549 if(!isWasmInitialized) {
43550 throw new Error("initializeWasm() must be awaited first!");
43552 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
43553 return nativeResponseValue;
43555 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
43557 export function RouteHint_eq(a: bigint, b: bigint): boolean {
43558 if(!isWasmInitialized) {
43559 throw new Error("initializeWasm() must be awaited first!");
43561 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
43562 return nativeResponseValue;
43564 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
43566 export function RouteHint_write(obj: bigint): number {
43567 if(!isWasmInitialized) {
43568 throw new Error("initializeWasm() must be awaited first!");
43570 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
43571 return nativeResponseValue;
43573 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
43575 export function RouteHint_read(ser: number): bigint {
43576 if(!isWasmInitialized) {
43577 throw new Error("initializeWasm() must be awaited first!");
43579 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
43580 return nativeResponseValue;
43582 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
43584 export function RouteHintHop_free(this_obj: bigint): void {
43585 if(!isWasmInitialized) {
43586 throw new Error("initializeWasm() must be awaited first!");
43588 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
43589 // debug statements here
43591 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
43593 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
43594 if(!isWasmInitialized) {
43595 throw new Error("initializeWasm() must be awaited first!");
43597 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
43598 return nativeResponseValue;
43600 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
43602 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
43603 if(!isWasmInitialized) {
43604 throw new Error("initializeWasm() must be awaited first!");
43606 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
43607 // debug statements here
43609 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
43611 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
43612 if(!isWasmInitialized) {
43613 throw new Error("initializeWasm() must be awaited first!");
43615 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
43616 return nativeResponseValue;
43618 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
43620 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
43621 if(!isWasmInitialized) {
43622 throw new Error("initializeWasm() must be awaited first!");
43624 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
43625 // debug statements here
43627 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
43629 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
43630 if(!isWasmInitialized) {
43631 throw new Error("initializeWasm() must be awaited first!");
43633 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
43634 return nativeResponseValue;
43636 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
43638 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
43639 if(!isWasmInitialized) {
43640 throw new Error("initializeWasm() must be awaited first!");
43642 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
43643 // debug statements here
43645 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
43647 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
43648 if(!isWasmInitialized) {
43649 throw new Error("initializeWasm() must be awaited first!");
43651 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
43652 return nativeResponseValue;
43654 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
43656 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
43657 if(!isWasmInitialized) {
43658 throw new Error("initializeWasm() must be awaited first!");
43660 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
43661 // debug statements here
43663 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
43665 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
43666 if(!isWasmInitialized) {
43667 throw new Error("initializeWasm() must be awaited first!");
43669 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
43670 return nativeResponseValue;
43672 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
43674 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
43675 if(!isWasmInitialized) {
43676 throw new Error("initializeWasm() must be awaited first!");
43678 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
43679 // debug statements here
43681 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
43683 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
43684 if(!isWasmInitialized) {
43685 throw new Error("initializeWasm() must be awaited first!");
43687 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
43688 return nativeResponseValue;
43690 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
43692 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
43693 if(!isWasmInitialized) {
43694 throw new Error("initializeWasm() must be awaited first!");
43696 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
43697 // debug statements here
43699 // 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);
43701 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 {
43702 if(!isWasmInitialized) {
43703 throw new Error("initializeWasm() must be awaited first!");
43705 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);
43706 return nativeResponseValue;
43708 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
43710 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
43711 if(!isWasmInitialized) {
43712 throw new Error("initializeWasm() must be awaited first!");
43714 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
43715 return nativeResponseValue;
43717 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
43719 export function RouteHintHop_clone(orig: bigint): bigint {
43720 if(!isWasmInitialized) {
43721 throw new Error("initializeWasm() must be awaited first!");
43723 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
43724 return nativeResponseValue;
43726 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
43728 export function RouteHintHop_hash(o: bigint): bigint {
43729 if(!isWasmInitialized) {
43730 throw new Error("initializeWasm() must be awaited first!");
43732 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
43733 return nativeResponseValue;
43735 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
43737 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
43738 if(!isWasmInitialized) {
43739 throw new Error("initializeWasm() must be awaited first!");
43741 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
43742 return nativeResponseValue;
43744 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
43746 export function RouteHintHop_write(obj: bigint): number {
43747 if(!isWasmInitialized) {
43748 throw new Error("initializeWasm() must be awaited first!");
43750 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
43751 return nativeResponseValue;
43753 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
43755 export function RouteHintHop_read(ser: number): bigint {
43756 if(!isWasmInitialized) {
43757 throw new Error("initializeWasm() must be awaited first!");
43759 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
43760 return nativeResponseValue;
43762 // 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 struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params, const uint8_t (*random_seed_bytes)[32]);
43764 export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, score_params: bigint, random_seed_bytes: number): bigint {
43765 if(!isWasmInitialized) {
43766 throw new Error("initializeWasm() must be awaited first!");
43768 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, score_params, random_seed_bytes);
43769 return nativeResponseValue;
43771 // 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]);
43773 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 {
43774 if(!isWasmInitialized) {
43775 throw new Error("initializeWasm() must be awaited first!");
43777 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
43778 return nativeResponseValue;
43780 // void Score_free(struct LDKScore this_ptr);
43782 export function Score_free(this_ptr: bigint): void {
43783 if(!isWasmInitialized) {
43784 throw new Error("initializeWasm() must be awaited first!");
43786 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
43787 // debug statements here
43789 // void LockableScore_free(struct LDKLockableScore this_ptr);
43791 export function LockableScore_free(this_ptr: bigint): void {
43792 if(!isWasmInitialized) {
43793 throw new Error("initializeWasm() must be awaited first!");
43795 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
43796 // debug statements here
43798 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
43800 export function WriteableScore_free(this_ptr: bigint): void {
43801 if(!isWasmInitialized) {
43802 throw new Error("initializeWasm() must be awaited first!");
43804 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
43805 // debug statements here
43807 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
43809 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
43810 if(!isWasmInitialized) {
43811 throw new Error("initializeWasm() must be awaited first!");
43813 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
43814 // debug statements here
43816 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
43818 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
43819 if(!isWasmInitialized) {
43820 throw new Error("initializeWasm() must be awaited first!");
43822 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
43823 return nativeResponseValue;
43825 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
43827 export function MultiThreadedLockableScore_write(obj: bigint): number {
43828 if(!isWasmInitialized) {
43829 throw new Error("initializeWasm() must be awaited first!");
43831 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
43832 return nativeResponseValue;
43834 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
43836 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
43837 if(!isWasmInitialized) {
43838 throw new Error("initializeWasm() must be awaited first!");
43840 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
43841 return nativeResponseValue;
43843 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
43845 export function MultiThreadedLockableScore_new(score: bigint): bigint {
43846 if(!isWasmInitialized) {
43847 throw new Error("initializeWasm() must be awaited first!");
43849 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
43850 return nativeResponseValue;
43852 // void MultiThreadedScoreLock_free(struct LDKMultiThreadedScoreLock this_obj);
43854 export function MultiThreadedScoreLock_free(this_obj: bigint): void {
43855 if(!isWasmInitialized) {
43856 throw new Error("initializeWasm() must be awaited first!");
43858 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_free(this_obj);
43859 // debug statements here
43861 // struct LDKCVec_u8Z MultiThreadedScoreLock_write(const struct LDKMultiThreadedScoreLock *NONNULL_PTR obj);
43863 export function MultiThreadedScoreLock_write(obj: bigint): number {
43864 if(!isWasmInitialized) {
43865 throw new Error("initializeWasm() must be awaited first!");
43867 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_write(obj);
43868 return nativeResponseValue;
43870 // struct LDKScore MultiThreadedScoreLock_as_Score(const struct LDKMultiThreadedScoreLock *NONNULL_PTR this_arg);
43872 export function MultiThreadedScoreLock_as_Score(this_arg: bigint): bigint {
43873 if(!isWasmInitialized) {
43874 throw new Error("initializeWasm() must be awaited first!");
43876 const nativeResponseValue = wasm.TS_MultiThreadedScoreLock_as_Score(this_arg);
43877 return nativeResponseValue;
43879 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
43881 export function ChannelUsage_free(this_obj: bigint): void {
43882 if(!isWasmInitialized) {
43883 throw new Error("initializeWasm() must be awaited first!");
43885 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
43886 // debug statements here
43888 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
43890 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
43891 if(!isWasmInitialized) {
43892 throw new Error("initializeWasm() must be awaited first!");
43894 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
43895 return nativeResponseValue;
43897 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
43899 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
43900 if(!isWasmInitialized) {
43901 throw new Error("initializeWasm() must be awaited first!");
43903 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
43904 // debug statements here
43906 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
43908 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
43909 if(!isWasmInitialized) {
43910 throw new Error("initializeWasm() must be awaited first!");
43912 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
43913 return nativeResponseValue;
43915 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
43917 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
43918 if(!isWasmInitialized) {
43919 throw new Error("initializeWasm() must be awaited first!");
43921 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
43922 // debug statements here
43924 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
43926 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
43927 if(!isWasmInitialized) {
43928 throw new Error("initializeWasm() must be awaited first!");
43930 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
43931 return nativeResponseValue;
43933 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
43935 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
43936 if(!isWasmInitialized) {
43937 throw new Error("initializeWasm() must be awaited first!");
43939 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
43940 // debug statements here
43942 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
43944 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
43945 if(!isWasmInitialized) {
43946 throw new Error("initializeWasm() must be awaited first!");
43948 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
43949 return nativeResponseValue;
43951 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
43953 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
43954 if(!isWasmInitialized) {
43955 throw new Error("initializeWasm() must be awaited first!");
43957 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
43958 return nativeResponseValue;
43960 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
43962 export function ChannelUsage_clone(orig: bigint): bigint {
43963 if(!isWasmInitialized) {
43964 throw new Error("initializeWasm() must be awaited first!");
43966 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
43967 return nativeResponseValue;
43969 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
43971 export function FixedPenaltyScorer_free(this_obj: bigint): void {
43972 if(!isWasmInitialized) {
43973 throw new Error("initializeWasm() must be awaited first!");
43975 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
43976 // debug statements here
43978 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
43980 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
43981 if(!isWasmInitialized) {
43982 throw new Error("initializeWasm() must be awaited first!");
43984 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
43985 return nativeResponseValue;
43987 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
43989 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
43990 if(!isWasmInitialized) {
43991 throw new Error("initializeWasm() must be awaited first!");
43993 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
43994 return nativeResponseValue;
43996 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
43998 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
43999 if(!isWasmInitialized) {
44000 throw new Error("initializeWasm() must be awaited first!");
44002 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
44003 return nativeResponseValue;
44005 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
44007 export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
44008 if(!isWasmInitialized) {
44009 throw new Error("initializeWasm() must be awaited first!");
44011 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
44012 return nativeResponseValue;
44014 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
44016 export function FixedPenaltyScorer_write(obj: bigint): number {
44017 if(!isWasmInitialized) {
44018 throw new Error("initializeWasm() must be awaited first!");
44020 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
44021 return nativeResponseValue;
44023 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
44025 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
44026 if(!isWasmInitialized) {
44027 throw new Error("initializeWasm() must be awaited first!");
44029 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
44030 return nativeResponseValue;
44032 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
44034 export function ProbabilisticScorer_free(this_obj: bigint): void {
44035 if(!isWasmInitialized) {
44036 throw new Error("initializeWasm() must be awaited first!");
44038 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
44039 // debug statements here
44041 // void ProbabilisticScoringFeeParameters_free(struct LDKProbabilisticScoringFeeParameters this_obj);
44043 export function ProbabilisticScoringFeeParameters_free(this_obj: bigint): void {
44044 if(!isWasmInitialized) {
44045 throw new Error("initializeWasm() must be awaited first!");
44047 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_free(this_obj);
44048 // debug statements here
44050 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44052 export function ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
44053 if(!isWasmInitialized) {
44054 throw new Error("initializeWasm() must be awaited first!");
44056 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr);
44057 return nativeResponseValue;
44059 // void ProbabilisticScoringFeeParameters_set_base_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44061 export function ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
44062 if(!isWasmInitialized) {
44063 throw new Error("initializeWasm() must be awaited first!");
44065 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr, val);
44066 // debug statements here
44068 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44070 export function ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
44071 if(!isWasmInitialized) {
44072 throw new Error("initializeWasm() must be awaited first!");
44074 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
44075 return nativeResponseValue;
44077 // void ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44079 export function ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
44080 if(!isWasmInitialized) {
44081 throw new Error("initializeWasm() must be awaited first!");
44083 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
44084 // debug statements here
44086 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44088 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
44089 if(!isWasmInitialized) {
44090 throw new Error("initializeWasm() must be awaited first!");
44092 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
44093 return nativeResponseValue;
44095 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44097 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
44098 if(!isWasmInitialized) {
44099 throw new Error("initializeWasm() must be awaited first!");
44101 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
44102 // debug statements here
44104 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44106 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
44107 if(!isWasmInitialized) {
44108 throw new Error("initializeWasm() must be awaited first!");
44110 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
44111 return nativeResponseValue;
44113 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44115 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
44116 if(!isWasmInitialized) {
44117 throw new Error("initializeWasm() must be awaited first!");
44119 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
44120 // debug statements here
44122 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44124 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
44125 if(!isWasmInitialized) {
44126 throw new Error("initializeWasm() must be awaited first!");
44128 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
44129 return nativeResponseValue;
44131 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44133 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
44134 if(!isWasmInitialized) {
44135 throw new Error("initializeWasm() must be awaited first!");
44137 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
44138 // debug statements here
44140 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44142 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
44143 if(!isWasmInitialized) {
44144 throw new Error("initializeWasm() must be awaited first!");
44146 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
44147 return nativeResponseValue;
44149 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44151 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
44152 if(!isWasmInitialized) {
44153 throw new Error("initializeWasm() must be awaited first!");
44155 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
44156 // debug statements here
44158 // uint64_t ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44160 export function ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
44161 if(!isWasmInitialized) {
44162 throw new Error("initializeWasm() must be awaited first!");
44164 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr);
44165 return nativeResponseValue;
44167 // void ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44169 export function ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
44170 if(!isWasmInitialized) {
44171 throw new Error("initializeWasm() must be awaited first!");
44173 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr, val);
44174 // debug statements here
44176 // uint64_t ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
44178 export function ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
44179 if(!isWasmInitialized) {
44180 throw new Error("initializeWasm() must be awaited first!");
44182 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr);
44183 return nativeResponseValue;
44185 // void ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
44187 export function ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
44188 if(!isWasmInitialized) {
44189 throw new Error("initializeWasm() must be awaited first!");
44191 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr, val);
44192 // debug statements here
44194 // uint64_t ProbabilisticScoringFeeParameters_clone_ptr(LDKProbabilisticScoringFeeParameters *NONNULL_PTR arg);
44196 export function ProbabilisticScoringFeeParameters_clone_ptr(arg: bigint): bigint {
44197 if(!isWasmInitialized) {
44198 throw new Error("initializeWasm() must be awaited first!");
44200 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone_ptr(arg);
44201 return nativeResponseValue;
44203 // struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_clone(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR orig);
44205 export function ProbabilisticScoringFeeParameters_clone(orig: bigint): bigint {
44206 if(!isWasmInitialized) {
44207 throw new Error("initializeWasm() must be awaited first!");
44209 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone(orig);
44210 return nativeResponseValue;
44212 // MUST_USE_RES struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_default(void);
44214 export function ProbabilisticScoringFeeParameters_default(): bigint {
44215 if(!isWasmInitialized) {
44216 throw new Error("initializeWasm() must be awaited first!");
44218 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_default();
44219 return nativeResponseValue;
44221 // void ProbabilisticScoringFeeParameters_add_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
44223 export function ProbabilisticScoringFeeParameters_add_banned(this_arg: bigint, node_id: bigint): void {
44224 if(!isWasmInitialized) {
44225 throw new Error("initializeWasm() must be awaited first!");
44227 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned(this_arg, node_id);
44228 // debug statements here
44230 // void ProbabilisticScoringFeeParameters_add_banned_from_list(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
44232 export function ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
44233 if(!isWasmInitialized) {
44234 throw new Error("initializeWasm() must be awaited first!");
44236 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg, node_ids);
44237 // debug statements here
44239 // void ProbabilisticScoringFeeParameters_remove_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
44241 export function ProbabilisticScoringFeeParameters_remove_banned(this_arg: bigint, node_id: bigint): void {
44242 if(!isWasmInitialized) {
44243 throw new Error("initializeWasm() must be awaited first!");
44245 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_banned(this_arg, node_id);
44246 // debug statements here
44248 // void ProbabilisticScoringFeeParameters_set_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
44250 export function ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
44251 if(!isWasmInitialized) {
44252 throw new Error("initializeWasm() must be awaited first!");
44254 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg, node_id, penalty);
44255 // debug statements here
44257 // void ProbabilisticScoringFeeParameters_remove_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
44259 export function ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
44260 if(!isWasmInitialized) {
44261 throw new Error("initializeWasm() must be awaited first!");
44263 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg, node_id);
44264 // debug statements here
44266 // void ProbabilisticScoringFeeParameters_clear_manual_penalties(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg);
44268 export function ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg: bigint): void {
44269 if(!isWasmInitialized) {
44270 throw new Error("initializeWasm() must be awaited first!");
44272 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg);
44273 // debug statements here
44275 // void ProbabilisticScoringDecayParameters_free(struct LDKProbabilisticScoringDecayParameters this_obj);
44277 export function ProbabilisticScoringDecayParameters_free(this_obj: bigint): void {
44278 if(!isWasmInitialized) {
44279 throw new Error("initializeWasm() must be awaited first!");
44281 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_free(this_obj);
44282 // debug statements here
44284 // uint64_t ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
44286 export function ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
44287 if(!isWasmInitialized) {
44288 throw new Error("initializeWasm() must be awaited first!");
44290 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr);
44291 return nativeResponseValue;
44293 // void ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
44295 export function ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
44296 if(!isWasmInitialized) {
44297 throw new Error("initializeWasm() must be awaited first!");
44299 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr, val);
44300 // debug statements here
44302 // uint64_t ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
44304 export function ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
44305 if(!isWasmInitialized) {
44306 throw new Error("initializeWasm() must be awaited first!");
44308 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr);
44309 return nativeResponseValue;
44311 // void ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
44313 export function ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
44314 if(!isWasmInitialized) {
44315 throw new Error("initializeWasm() must be awaited first!");
44317 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr, val);
44318 // debug statements here
44320 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_new(uint64_t historical_no_updates_half_life_arg, uint64_t liquidity_offset_half_life_arg);
44322 export function ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg: bigint, liquidity_offset_half_life_arg: bigint): bigint {
44323 if(!isWasmInitialized) {
44324 throw new Error("initializeWasm() must be awaited first!");
44326 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg, liquidity_offset_half_life_arg);
44327 return nativeResponseValue;
44329 // uint64_t ProbabilisticScoringDecayParameters_clone_ptr(LDKProbabilisticScoringDecayParameters *NONNULL_PTR arg);
44331 export function ProbabilisticScoringDecayParameters_clone_ptr(arg: bigint): bigint {
44332 if(!isWasmInitialized) {
44333 throw new Error("initializeWasm() must be awaited first!");
44335 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone_ptr(arg);
44336 return nativeResponseValue;
44338 // struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_clone(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR orig);
44340 export function ProbabilisticScoringDecayParameters_clone(orig: bigint): bigint {
44341 if(!isWasmInitialized) {
44342 throw new Error("initializeWasm() must be awaited first!");
44344 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone(orig);
44345 return nativeResponseValue;
44347 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_default(void);
44349 export function ProbabilisticScoringDecayParameters_default(): bigint {
44350 if(!isWasmInitialized) {
44351 throw new Error("initializeWasm() must be awaited first!");
44353 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_default();
44354 return nativeResponseValue;
44356 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringDecayParameters decay_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
44358 export function ProbabilisticScorer_new(decay_params: bigint, network_graph: bigint, logger: bigint): bigint {
44359 if(!isWasmInitialized) {
44360 throw new Error("initializeWasm() must be awaited first!");
44362 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(decay_params, network_graph, logger);
44363 return nativeResponseValue;
44365 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
44367 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
44368 if(!isWasmInitialized) {
44369 throw new Error("initializeWasm() must be awaited first!");
44371 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
44372 // debug statements here
44374 // 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);
44376 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
44377 if(!isWasmInitialized) {
44378 throw new Error("initializeWasm() must be awaited first!");
44380 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
44381 return nativeResponseValue;
44383 // 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);
44385 export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
44386 if(!isWasmInitialized) {
44387 throw new Error("initializeWasm() must be awaited first!");
44389 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
44390 return nativeResponseValue;
44392 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
44394 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
44395 if(!isWasmInitialized) {
44396 throw new Error("initializeWasm() must be awaited first!");
44398 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
44399 return nativeResponseValue;
44401 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
44403 export function ProbabilisticScorer_write(obj: bigint): number {
44404 if(!isWasmInitialized) {
44405 throw new Error("initializeWasm() must be awaited first!");
44407 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
44408 return nativeResponseValue;
44410 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringDecayParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
44412 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
44413 if(!isWasmInitialized) {
44414 throw new Error("initializeWasm() must be awaited first!");
44416 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
44417 return nativeResponseValue;
44419 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
44421 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
44422 if(!isWasmInitialized) {
44423 throw new Error("initializeWasm() must be awaited first!");
44425 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
44426 // debug statements here
44428 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44430 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
44431 if(!isWasmInitialized) {
44432 throw new Error("initializeWasm() must be awaited first!");
44434 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
44435 return nativeResponseValue;
44437 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
44439 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
44440 if(!isWasmInitialized) {
44441 throw new Error("initializeWasm() must be awaited first!");
44443 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
44444 // debug statements here
44446 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44448 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
44449 if(!isWasmInitialized) {
44450 throw new Error("initializeWasm() must be awaited first!");
44452 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
44453 return nativeResponseValue;
44455 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
44457 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
44458 if(!isWasmInitialized) {
44459 throw new Error("initializeWasm() must be awaited first!");
44461 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
44462 // debug statements here
44464 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44466 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
44467 if(!isWasmInitialized) {
44468 throw new Error("initializeWasm() must be awaited first!");
44470 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
44471 return nativeResponseValue;
44473 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
44475 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
44476 if(!isWasmInitialized) {
44477 throw new Error("initializeWasm() must be awaited first!");
44479 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
44480 // debug statements here
44482 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44484 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
44485 if(!isWasmInitialized) {
44486 throw new Error("initializeWasm() must be awaited first!");
44488 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
44489 return nativeResponseValue;
44491 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
44493 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
44494 if(!isWasmInitialized) {
44495 throw new Error("initializeWasm() must be awaited first!");
44497 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
44498 // debug statements here
44500 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44502 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
44503 if(!isWasmInitialized) {
44504 throw new Error("initializeWasm() must be awaited first!");
44506 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
44507 return nativeResponseValue;
44509 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
44511 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
44512 if(!isWasmInitialized) {
44513 throw new Error("initializeWasm() must be awaited first!");
44515 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
44516 // debug statements here
44518 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
44520 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
44521 if(!isWasmInitialized) {
44522 throw new Error("initializeWasm() must be awaited first!");
44524 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
44525 return nativeResponseValue;
44527 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
44529 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
44530 if(!isWasmInitialized) {
44531 throw new Error("initializeWasm() must be awaited first!");
44533 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
44534 // debug statements here
44536 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44538 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
44539 if(!isWasmInitialized) {
44540 throw new Error("initializeWasm() must be awaited first!");
44542 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
44543 return nativeResponseValue;
44545 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
44547 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
44548 if(!isWasmInitialized) {
44549 throw new Error("initializeWasm() must be awaited first!");
44551 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
44552 // debug statements here
44554 // 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);
44556 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 {
44557 if(!isWasmInitialized) {
44558 throw new Error("initializeWasm() must be awaited first!");
44560 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);
44561 return nativeResponseValue;
44563 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
44565 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
44566 if(!isWasmInitialized) {
44567 throw new Error("initializeWasm() must be awaited first!");
44569 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
44570 return nativeResponseValue;
44572 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
44574 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
44575 if(!isWasmInitialized) {
44576 throw new Error("initializeWasm() must be awaited first!");
44578 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
44579 return nativeResponseValue;
44581 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
44583 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
44584 if(!isWasmInitialized) {
44585 throw new Error("initializeWasm() must be awaited first!");
44587 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
44588 return nativeResponseValue;
44590 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
44592 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
44593 if(!isWasmInitialized) {
44594 throw new Error("initializeWasm() must be awaited first!");
44596 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
44597 return nativeResponseValue;
44599 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
44601 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
44602 if(!isWasmInitialized) {
44603 throw new Error("initializeWasm() must be awaited first!");
44605 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
44606 return nativeResponseValue;
44608 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
44610 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
44611 if(!isWasmInitialized) {
44612 throw new Error("initializeWasm() must be awaited first!");
44614 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
44615 // debug statements here
44617 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44619 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
44620 if(!isWasmInitialized) {
44621 throw new Error("initializeWasm() must be awaited first!");
44623 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
44624 return nativeResponseValue;
44626 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
44628 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
44629 if(!isWasmInitialized) {
44630 throw new Error("initializeWasm() must be awaited first!");
44632 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
44633 // debug statements here
44635 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44637 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
44638 if(!isWasmInitialized) {
44639 throw new Error("initializeWasm() must be awaited first!");
44641 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
44642 return nativeResponseValue;
44644 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
44646 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
44647 if(!isWasmInitialized) {
44648 throw new Error("initializeWasm() must be awaited first!");
44650 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
44651 // debug statements here
44653 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
44655 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
44656 if(!isWasmInitialized) {
44657 throw new Error("initializeWasm() must be awaited first!");
44659 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
44660 return nativeResponseValue;
44662 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
44664 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
44665 if(!isWasmInitialized) {
44666 throw new Error("initializeWasm() must be awaited first!");
44668 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
44669 // debug statements here
44671 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
44673 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
44674 if(!isWasmInitialized) {
44675 throw new Error("initializeWasm() must be awaited first!");
44677 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
44678 return nativeResponseValue;
44680 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
44682 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
44683 if(!isWasmInitialized) {
44684 throw new Error("initializeWasm() must be awaited first!");
44686 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
44687 // debug statements here
44689 // 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);
44691 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
44692 if(!isWasmInitialized) {
44693 throw new Error("initializeWasm() must be awaited first!");
44695 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
44696 return nativeResponseValue;
44698 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
44700 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
44701 if(!isWasmInitialized) {
44702 throw new Error("initializeWasm() must be awaited first!");
44704 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
44705 return nativeResponseValue;
44707 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
44709 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
44710 if(!isWasmInitialized) {
44711 throw new Error("initializeWasm() must be awaited first!");
44713 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
44714 return nativeResponseValue;
44716 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
44718 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
44719 if(!isWasmInitialized) {
44720 throw new Error("initializeWasm() must be awaited first!");
44722 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
44723 return nativeResponseValue;
44725 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
44727 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
44728 if(!isWasmInitialized) {
44729 throw new Error("initializeWasm() must be awaited first!");
44731 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
44732 return nativeResponseValue;
44734 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
44736 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
44737 if(!isWasmInitialized) {
44738 throw new Error("initializeWasm() must be awaited first!");
44740 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
44741 return nativeResponseValue;
44743 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
44745 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
44746 if(!isWasmInitialized) {
44747 throw new Error("initializeWasm() must be awaited first!");
44749 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
44750 // debug statements here
44752 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
44754 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
44755 if(!isWasmInitialized) {
44756 throw new Error("initializeWasm() must be awaited first!");
44758 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
44759 return nativeResponseValue;
44761 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
44763 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
44764 if(!isWasmInitialized) {
44765 throw new Error("initializeWasm() must be awaited first!");
44767 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
44768 return nativeResponseValue;
44770 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
44772 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
44773 if(!isWasmInitialized) {
44774 throw new Error("initializeWasm() must be awaited first!");
44776 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
44777 return nativeResponseValue;
44779 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
44781 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
44782 if(!isWasmInitialized) {
44783 throw new Error("initializeWasm() must be awaited first!");
44785 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
44786 return nativeResponseValue;
44788 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
44790 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
44791 if(!isWasmInitialized) {
44792 throw new Error("initializeWasm() must be awaited first!");
44794 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
44795 return nativeResponseValue;
44797 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
44799 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
44800 if(!isWasmInitialized) {
44801 throw new Error("initializeWasm() must be awaited first!");
44803 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
44804 return nativeResponseValue;
44806 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
44808 export function SpendableOutputDescriptor_write(obj: bigint): number {
44809 if(!isWasmInitialized) {
44810 throw new Error("initializeWasm() must be awaited first!");
44812 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
44813 return nativeResponseValue;
44815 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
44817 export function SpendableOutputDescriptor_read(ser: number): bigint {
44818 if(!isWasmInitialized) {
44819 throw new Error("initializeWasm() must be awaited first!");
44821 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
44822 return nativeResponseValue;
44824 // MUST_USE_RES struct LDKCResult_C2Tuple_PartiallySignedTransactionusizeZNoneZ SpendableOutputDescriptor_create_spendable_outputs_psbt(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_PackedLockTimeZ locktime);
44826 export function SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
44827 if(!isWasmInitialized) {
44828 throw new Error("initializeWasm() must be awaited first!");
44830 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
44831 return nativeResponseValue;
44833 // void ChannelSigner_free(struct LDKChannelSigner this_ptr);
44835 export function ChannelSigner_free(this_ptr: bigint): void {
44836 if(!isWasmInitialized) {
44837 throw new Error("initializeWasm() must be awaited first!");
44839 const nativeResponseValue = wasm.TS_ChannelSigner_free(this_ptr);
44840 // debug statements here
44842 // void EcdsaChannelSigner_free(struct LDKEcdsaChannelSigner this_ptr);
44844 export function EcdsaChannelSigner_free(this_ptr: bigint): void {
44845 if(!isWasmInitialized) {
44846 throw new Error("initializeWasm() must be awaited first!");
44848 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_free(this_ptr);
44849 // debug statements here
44851 // uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg);
44853 export function WriteableEcdsaChannelSigner_clone_ptr(arg: bigint): bigint {
44854 if(!isWasmInitialized) {
44855 throw new Error("initializeWasm() must be awaited first!");
44857 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone_ptr(arg);
44858 return nativeResponseValue;
44860 // struct LDKWriteableEcdsaChannelSigner WriteableEcdsaChannelSigner_clone(const struct LDKWriteableEcdsaChannelSigner *NONNULL_PTR orig);
44862 export function WriteableEcdsaChannelSigner_clone(orig: bigint): bigint {
44863 if(!isWasmInitialized) {
44864 throw new Error("initializeWasm() must be awaited first!");
44866 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone(orig);
44867 return nativeResponseValue;
44869 // void WriteableEcdsaChannelSigner_free(struct LDKWriteableEcdsaChannelSigner this_ptr);
44871 export function WriteableEcdsaChannelSigner_free(this_ptr: bigint): void {
44872 if(!isWasmInitialized) {
44873 throw new Error("initializeWasm() must be awaited first!");
44875 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_free(this_ptr);
44876 // debug statements here
44878 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
44880 export function Recipient_clone(orig: bigint): Recipient {
44881 if(!isWasmInitialized) {
44882 throw new Error("initializeWasm() must be awaited first!");
44884 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
44885 return nativeResponseValue;
44887 // enum LDKRecipient Recipient_node(void);
44889 export function Recipient_node(): Recipient {
44890 if(!isWasmInitialized) {
44891 throw new Error("initializeWasm() must be awaited first!");
44893 const nativeResponseValue = wasm.TS_Recipient_node();
44894 return nativeResponseValue;
44896 // enum LDKRecipient Recipient_phantom_node(void);
44898 export function Recipient_phantom_node(): Recipient {
44899 if(!isWasmInitialized) {
44900 throw new Error("initializeWasm() must be awaited first!");
44902 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
44903 return nativeResponseValue;
44905 // void EntropySource_free(struct LDKEntropySource this_ptr);
44907 export function EntropySource_free(this_ptr: bigint): void {
44908 if(!isWasmInitialized) {
44909 throw new Error("initializeWasm() must be awaited first!");
44911 const nativeResponseValue = wasm.TS_EntropySource_free(this_ptr);
44912 // debug statements here
44914 // void NodeSigner_free(struct LDKNodeSigner this_ptr);
44916 export function NodeSigner_free(this_ptr: bigint): void {
44917 if(!isWasmInitialized) {
44918 throw new Error("initializeWasm() must be awaited first!");
44920 const nativeResponseValue = wasm.TS_NodeSigner_free(this_ptr);
44921 // debug statements here
44923 // void SignerProvider_free(struct LDKSignerProvider this_ptr);
44925 export function SignerProvider_free(this_ptr: bigint): void {
44926 if(!isWasmInitialized) {
44927 throw new Error("initializeWasm() must be awaited first!");
44929 const nativeResponseValue = wasm.TS_SignerProvider_free(this_ptr);
44930 // debug statements here
44932 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
44934 export function InMemorySigner_free(this_obj: bigint): void {
44935 if(!isWasmInitialized) {
44936 throw new Error("initializeWasm() must be awaited first!");
44938 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
44939 // debug statements here
44941 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
44943 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
44944 if(!isWasmInitialized) {
44945 throw new Error("initializeWasm() must be awaited first!");
44947 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
44948 return nativeResponseValue;
44950 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
44952 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
44953 if(!isWasmInitialized) {
44954 throw new Error("initializeWasm() must be awaited first!");
44956 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
44957 // debug statements here
44959 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
44961 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
44962 if(!isWasmInitialized) {
44963 throw new Error("initializeWasm() must be awaited first!");
44965 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
44966 return nativeResponseValue;
44968 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
44970 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
44971 if(!isWasmInitialized) {
44972 throw new Error("initializeWasm() must be awaited first!");
44974 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
44975 // debug statements here
44977 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
44979 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
44980 if(!isWasmInitialized) {
44981 throw new Error("initializeWasm() must be awaited first!");
44983 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
44984 return nativeResponseValue;
44986 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
44988 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
44989 if(!isWasmInitialized) {
44990 throw new Error("initializeWasm() must be awaited first!");
44992 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
44993 // debug statements here
44995 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
44997 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
44998 if(!isWasmInitialized) {
44999 throw new Error("initializeWasm() must be awaited first!");
45001 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
45002 return nativeResponseValue;
45004 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
45006 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
45007 if(!isWasmInitialized) {
45008 throw new Error("initializeWasm() must be awaited first!");
45010 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
45011 // debug statements here
45013 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
45015 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
45016 if(!isWasmInitialized) {
45017 throw new Error("initializeWasm() must be awaited first!");
45019 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
45020 return nativeResponseValue;
45022 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
45024 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
45025 if(!isWasmInitialized) {
45026 throw new Error("initializeWasm() must be awaited first!");
45028 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
45029 // debug statements here
45031 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
45033 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
45034 if(!isWasmInitialized) {
45035 throw new Error("initializeWasm() must be awaited first!");
45037 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
45038 return nativeResponseValue;
45040 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
45042 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
45043 if(!isWasmInitialized) {
45044 throw new Error("initializeWasm() must be awaited first!");
45046 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
45047 // debug statements here
45049 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
45051 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
45052 if(!isWasmInitialized) {
45053 throw new Error("initializeWasm() must be awaited first!");
45055 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
45056 return nativeResponseValue;
45058 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
45060 export function InMemorySigner_clone(orig: bigint): bigint {
45061 if(!isWasmInitialized) {
45062 throw new Error("initializeWasm() must be awaited first!");
45064 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
45065 return nativeResponseValue;
45067 // 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, struct LDKThirtyTwoBytes rand_bytes_unique_start);
45069 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, rand_bytes_unique_start: number): bigint {
45070 if(!isWasmInitialized) {
45071 throw new Error("initializeWasm() must be awaited first!");
45073 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, rand_bytes_unique_start);
45074 return nativeResponseValue;
45076 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45078 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
45079 if(!isWasmInitialized) {
45080 throw new Error("initializeWasm() must be awaited first!");
45082 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
45083 return nativeResponseValue;
45085 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45087 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): number {
45088 if(!isWasmInitialized) {
45089 throw new Error("initializeWasm() must be awaited first!");
45091 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
45092 return nativeResponseValue;
45094 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45096 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): number {
45097 if(!isWasmInitialized) {
45098 throw new Error("initializeWasm() must be awaited first!");
45100 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
45101 return nativeResponseValue;
45103 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45105 export function InMemorySigner_is_outbound(this_arg: bigint): boolean {
45106 if(!isWasmInitialized) {
45107 throw new Error("initializeWasm() must be awaited first!");
45109 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
45110 return nativeResponseValue;
45112 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45114 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
45115 if(!isWasmInitialized) {
45116 throw new Error("initializeWasm() must be awaited first!");
45118 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
45119 return nativeResponseValue;
45121 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45123 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
45124 if(!isWasmInitialized) {
45125 throw new Error("initializeWasm() must be awaited first!");
45127 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
45128 return nativeResponseValue;
45130 // MUST_USE_RES struct LDKChannelTypeFeatures InMemorySigner_channel_type_features(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45132 export function InMemorySigner_channel_type_features(this_arg: bigint): bigint {
45133 if(!isWasmInitialized) {
45134 throw new Error("initializeWasm() must be awaited first!");
45136 const nativeResponseValue = wasm.TS_InMemorySigner_channel_type_features(this_arg);
45137 return nativeResponseValue;
45139 // 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);
45141 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
45142 if(!isWasmInitialized) {
45143 throw new Error("initializeWasm() must be awaited first!");
45145 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
45146 return nativeResponseValue;
45148 // 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);
45150 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
45151 if(!isWasmInitialized) {
45152 throw new Error("initializeWasm() must be awaited first!");
45154 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
45155 return nativeResponseValue;
45157 // struct LDKEntropySource InMemorySigner_as_EntropySource(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45159 export function InMemorySigner_as_EntropySource(this_arg: bigint): bigint {
45160 if(!isWasmInitialized) {
45161 throw new Error("initializeWasm() must be awaited first!");
45163 const nativeResponseValue = wasm.TS_InMemorySigner_as_EntropySource(this_arg);
45164 return nativeResponseValue;
45166 // struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45168 export function InMemorySigner_as_ChannelSigner(this_arg: bigint): bigint {
45169 if(!isWasmInitialized) {
45170 throw new Error("initializeWasm() must be awaited first!");
45172 const nativeResponseValue = wasm.TS_InMemorySigner_as_ChannelSigner(this_arg);
45173 return nativeResponseValue;
45175 // struct LDKEcdsaChannelSigner InMemorySigner_as_EcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45177 export function InMemorySigner_as_EcdsaChannelSigner(this_arg: bigint): bigint {
45178 if(!isWasmInitialized) {
45179 throw new Error("initializeWasm() must be awaited first!");
45181 const nativeResponseValue = wasm.TS_InMemorySigner_as_EcdsaChannelSigner(this_arg);
45182 return nativeResponseValue;
45184 // struct LDKWriteableEcdsaChannelSigner InMemorySigner_as_WriteableEcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
45186 export function InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg: bigint): bigint {
45187 if(!isWasmInitialized) {
45188 throw new Error("initializeWasm() must be awaited first!");
45190 const nativeResponseValue = wasm.TS_InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg);
45191 return nativeResponseValue;
45193 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
45195 export function InMemorySigner_write(obj: bigint): number {
45196 if(!isWasmInitialized) {
45197 throw new Error("initializeWasm() must be awaited first!");
45199 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
45200 return nativeResponseValue;
45202 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKEntropySource arg);
45204 export function InMemorySigner_read(ser: number, arg: bigint): bigint {
45205 if(!isWasmInitialized) {
45206 throw new Error("initializeWasm() must be awaited first!");
45208 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
45209 return nativeResponseValue;
45211 // void KeysManager_free(struct LDKKeysManager this_obj);
45213 export function KeysManager_free(this_obj: bigint): void {
45214 if(!isWasmInitialized) {
45215 throw new Error("initializeWasm() must be awaited first!");
45217 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
45218 // debug statements here
45220 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
45222 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
45223 if(!isWasmInitialized) {
45224 throw new Error("initializeWasm() must be awaited first!");
45226 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
45227 return nativeResponseValue;
45229 // MUST_USE_RES struct LDKSecretKey KeysManager_get_node_secret_key(const struct LDKKeysManager *NONNULL_PTR this_arg);
45231 export function KeysManager_get_node_secret_key(this_arg: bigint): number {
45232 if(!isWasmInitialized) {
45233 throw new Error("initializeWasm() must be awaited first!");
45235 const nativeResponseValue = wasm.TS_KeysManager_get_node_secret_key(this_arg);
45236 return nativeResponseValue;
45238 // 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]);
45240 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
45241 if(!isWasmInitialized) {
45242 throw new Error("initializeWasm() must be awaited first!");
45244 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
45245 return nativeResponseValue;
45247 // MUST_USE_RES struct LDKCResult_PartiallySignedTransactionNoneZ KeysManager_sign_spendable_outputs_psbt(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_u8Z psbt);
45249 export function KeysManager_sign_spendable_outputs_psbt(this_arg: bigint, descriptors: number, psbt: number): bigint {
45250 if(!isWasmInitialized) {
45251 throw new Error("initializeWasm() must be awaited first!");
45253 const nativeResponseValue = wasm.TS_KeysManager_sign_spendable_outputs_psbt(this_arg, descriptors, psbt);
45254 return nativeResponseValue;
45256 // 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, struct LDKCOption_PackedLockTimeZ locktime);
45258 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
45259 if(!isWasmInitialized) {
45260 throw new Error("initializeWasm() must be awaited first!");
45262 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
45263 return nativeResponseValue;
45265 // struct LDKEntropySource KeysManager_as_EntropySource(const struct LDKKeysManager *NONNULL_PTR this_arg);
45267 export function KeysManager_as_EntropySource(this_arg: bigint): bigint {
45268 if(!isWasmInitialized) {
45269 throw new Error("initializeWasm() must be awaited first!");
45271 const nativeResponseValue = wasm.TS_KeysManager_as_EntropySource(this_arg);
45272 return nativeResponseValue;
45274 // struct LDKNodeSigner KeysManager_as_NodeSigner(const struct LDKKeysManager *NONNULL_PTR this_arg);
45276 export function KeysManager_as_NodeSigner(this_arg: bigint): bigint {
45277 if(!isWasmInitialized) {
45278 throw new Error("initializeWasm() must be awaited first!");
45280 const nativeResponseValue = wasm.TS_KeysManager_as_NodeSigner(this_arg);
45281 return nativeResponseValue;
45283 // struct LDKSignerProvider KeysManager_as_SignerProvider(const struct LDKKeysManager *NONNULL_PTR this_arg);
45285 export function KeysManager_as_SignerProvider(this_arg: bigint): bigint {
45286 if(!isWasmInitialized) {
45287 throw new Error("initializeWasm() must be awaited first!");
45289 const nativeResponseValue = wasm.TS_KeysManager_as_SignerProvider(this_arg);
45290 return nativeResponseValue;
45292 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
45294 export function PhantomKeysManager_free(this_obj: bigint): void {
45295 if(!isWasmInitialized) {
45296 throw new Error("initializeWasm() must be awaited first!");
45298 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
45299 // debug statements here
45301 // struct LDKEntropySource PhantomKeysManager_as_EntropySource(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
45303 export function PhantomKeysManager_as_EntropySource(this_arg: bigint): bigint {
45304 if(!isWasmInitialized) {
45305 throw new Error("initializeWasm() must be awaited first!");
45307 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_EntropySource(this_arg);
45308 return nativeResponseValue;
45310 // struct LDKNodeSigner PhantomKeysManager_as_NodeSigner(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
45312 export function PhantomKeysManager_as_NodeSigner(this_arg: bigint): bigint {
45313 if(!isWasmInitialized) {
45314 throw new Error("initializeWasm() must be awaited first!");
45316 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_NodeSigner(this_arg);
45317 return nativeResponseValue;
45319 // struct LDKSignerProvider PhantomKeysManager_as_SignerProvider(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
45321 export function PhantomKeysManager_as_SignerProvider(this_arg: bigint): bigint {
45322 if(!isWasmInitialized) {
45323 throw new Error("initializeWasm() must be awaited first!");
45325 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_SignerProvider(this_arg);
45326 return nativeResponseValue;
45328 // 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]);
45330 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
45331 if(!isWasmInitialized) {
45332 throw new Error("initializeWasm() must be awaited first!");
45334 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
45335 return nativeResponseValue;
45337 // 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, struct LDKCOption_PackedLockTimeZ locktime);
45339 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
45340 if(!isWasmInitialized) {
45341 throw new Error("initializeWasm() must be awaited first!");
45343 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
45344 return nativeResponseValue;
45346 // 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]);
45348 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
45349 if(!isWasmInitialized) {
45350 throw new Error("initializeWasm() must be awaited first!");
45352 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
45353 return nativeResponseValue;
45355 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
45357 export function PhantomKeysManager_get_node_secret_key(this_arg: bigint): number {
45358 if(!isWasmInitialized) {
45359 throw new Error("initializeWasm() must be awaited first!");
45361 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_node_secret_key(this_arg);
45362 return nativeResponseValue;
45364 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_phantom_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
45366 export function PhantomKeysManager_get_phantom_node_secret_key(this_arg: bigint): number {
45367 if(!isWasmInitialized) {
45368 throw new Error("initializeWasm() must be awaited first!");
45370 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_phantom_node_secret_key(this_arg);
45371 return nativeResponseValue;
45373 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
45375 export function OnionMessenger_free(this_obj: bigint): void {
45376 if(!isWasmInitialized) {
45377 throw new Error("initializeWasm() must be awaited first!");
45379 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
45380 // debug statements here
45382 // void MessageRouter_free(struct LDKMessageRouter this_ptr);
45384 export function MessageRouter_free(this_ptr: bigint): void {
45385 if(!isWasmInitialized) {
45386 throw new Error("initializeWasm() must be awaited first!");
45388 const nativeResponseValue = wasm.TS_MessageRouter_free(this_ptr);
45389 // debug statements here
45391 // void DefaultMessageRouter_free(struct LDKDefaultMessageRouter this_obj);
45393 export function DefaultMessageRouter_free(this_obj: bigint): void {
45394 if(!isWasmInitialized) {
45395 throw new Error("initializeWasm() must be awaited first!");
45397 const nativeResponseValue = wasm.TS_DefaultMessageRouter_free(this_obj);
45398 // debug statements here
45400 // MUST_USE_RES struct LDKDefaultMessageRouter DefaultMessageRouter_new(void);
45402 export function DefaultMessageRouter_new(): bigint {
45403 if(!isWasmInitialized) {
45404 throw new Error("initializeWasm() must be awaited first!");
45406 const nativeResponseValue = wasm.TS_DefaultMessageRouter_new();
45407 return nativeResponseValue;
45409 // struct LDKMessageRouter DefaultMessageRouter_as_MessageRouter(const struct LDKDefaultMessageRouter *NONNULL_PTR this_arg);
45411 export function DefaultMessageRouter_as_MessageRouter(this_arg: bigint): bigint {
45412 if(!isWasmInitialized) {
45413 throw new Error("initializeWasm() must be awaited first!");
45415 const nativeResponseValue = wasm.TS_DefaultMessageRouter_as_MessageRouter(this_arg);
45416 return nativeResponseValue;
45418 // void OnionMessagePath_free(struct LDKOnionMessagePath this_obj);
45420 export function OnionMessagePath_free(this_obj: bigint): void {
45421 if(!isWasmInitialized) {
45422 throw new Error("initializeWasm() must be awaited first!");
45424 const nativeResponseValue = wasm.TS_OnionMessagePath_free(this_obj);
45425 // debug statements here
45427 // struct LDKCVec_PublicKeyZ OnionMessagePath_get_intermediate_nodes(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
45429 export function OnionMessagePath_get_intermediate_nodes(this_ptr: bigint): number {
45430 if(!isWasmInitialized) {
45431 throw new Error("initializeWasm() must be awaited first!");
45433 const nativeResponseValue = wasm.TS_OnionMessagePath_get_intermediate_nodes(this_ptr);
45434 return nativeResponseValue;
45436 // void OnionMessagePath_set_intermediate_nodes(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCVec_PublicKeyZ val);
45438 export function OnionMessagePath_set_intermediate_nodes(this_ptr: bigint, val: number): void {
45439 if(!isWasmInitialized) {
45440 throw new Error("initializeWasm() must be awaited first!");
45442 const nativeResponseValue = wasm.TS_OnionMessagePath_set_intermediate_nodes(this_ptr, val);
45443 // debug statements here
45445 // struct LDKDestination OnionMessagePath_get_destination(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
45447 export function OnionMessagePath_get_destination(this_ptr: bigint): bigint {
45448 if(!isWasmInitialized) {
45449 throw new Error("initializeWasm() must be awaited first!");
45451 const nativeResponseValue = wasm.TS_OnionMessagePath_get_destination(this_ptr);
45452 return nativeResponseValue;
45454 // void OnionMessagePath_set_destination(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKDestination val);
45456 export function OnionMessagePath_set_destination(this_ptr: bigint, val: bigint): void {
45457 if(!isWasmInitialized) {
45458 throw new Error("initializeWasm() must be awaited first!");
45460 const nativeResponseValue = wasm.TS_OnionMessagePath_set_destination(this_ptr, val);
45461 // debug statements here
45463 // MUST_USE_RES struct LDKOnionMessagePath OnionMessagePath_new(struct LDKCVec_PublicKeyZ intermediate_nodes_arg, struct LDKDestination destination_arg);
45465 export function OnionMessagePath_new(intermediate_nodes_arg: number, destination_arg: bigint): bigint {
45466 if(!isWasmInitialized) {
45467 throw new Error("initializeWasm() must be awaited first!");
45469 const nativeResponseValue = wasm.TS_OnionMessagePath_new(intermediate_nodes_arg, destination_arg);
45470 return nativeResponseValue;
45472 // uint64_t OnionMessagePath_clone_ptr(LDKOnionMessagePath *NONNULL_PTR arg);
45474 export function OnionMessagePath_clone_ptr(arg: bigint): bigint {
45475 if(!isWasmInitialized) {
45476 throw new Error("initializeWasm() must be awaited first!");
45478 const nativeResponseValue = wasm.TS_OnionMessagePath_clone_ptr(arg);
45479 return nativeResponseValue;
45481 // struct LDKOnionMessagePath OnionMessagePath_clone(const struct LDKOnionMessagePath *NONNULL_PTR orig);
45483 export function OnionMessagePath_clone(orig: bigint): bigint {
45484 if(!isWasmInitialized) {
45485 throw new Error("initializeWasm() must be awaited first!");
45487 const nativeResponseValue = wasm.TS_OnionMessagePath_clone(orig);
45488 return nativeResponseValue;
45490 // void Destination_free(struct LDKDestination this_ptr);
45492 export function Destination_free(this_ptr: bigint): void {
45493 if(!isWasmInitialized) {
45494 throw new Error("initializeWasm() must be awaited first!");
45496 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
45497 // debug statements here
45499 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
45501 export function Destination_clone_ptr(arg: bigint): bigint {
45502 if(!isWasmInitialized) {
45503 throw new Error("initializeWasm() must be awaited first!");
45505 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
45506 return nativeResponseValue;
45508 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
45510 export function Destination_clone(orig: bigint): bigint {
45511 if(!isWasmInitialized) {
45512 throw new Error("initializeWasm() must be awaited first!");
45514 const nativeResponseValue = wasm.TS_Destination_clone(orig);
45515 return nativeResponseValue;
45517 // struct LDKDestination Destination_node(struct LDKPublicKey a);
45519 export function Destination_node(a: number): bigint {
45520 if(!isWasmInitialized) {
45521 throw new Error("initializeWasm() must be awaited first!");
45523 const nativeResponseValue = wasm.TS_Destination_node(a);
45524 return nativeResponseValue;
45526 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
45528 export function Destination_blinded_path(a: bigint): bigint {
45529 if(!isWasmInitialized) {
45530 throw new Error("initializeWasm() must be awaited first!");
45532 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
45533 return nativeResponseValue;
45535 // void SendError_free(struct LDKSendError this_ptr);
45537 export function SendError_free(this_ptr: bigint): void {
45538 if(!isWasmInitialized) {
45539 throw new Error("initializeWasm() must be awaited first!");
45541 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
45542 // debug statements here
45544 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
45546 export function SendError_clone_ptr(arg: bigint): bigint {
45547 if(!isWasmInitialized) {
45548 throw new Error("initializeWasm() must be awaited first!");
45550 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
45551 return nativeResponseValue;
45553 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
45555 export function SendError_clone(orig: bigint): bigint {
45556 if(!isWasmInitialized) {
45557 throw new Error("initializeWasm() must be awaited first!");
45559 const nativeResponseValue = wasm.TS_SendError_clone(orig);
45560 return nativeResponseValue;
45562 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
45564 export function SendError_secp256k1(a: Secp256k1Error): bigint {
45565 if(!isWasmInitialized) {
45566 throw new Error("initializeWasm() must be awaited first!");
45568 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
45569 return nativeResponseValue;
45571 // struct LDKSendError SendError_too_big_packet(void);
45573 export function SendError_too_big_packet(): bigint {
45574 if(!isWasmInitialized) {
45575 throw new Error("initializeWasm() must be awaited first!");
45577 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
45578 return nativeResponseValue;
45580 // struct LDKSendError SendError_too_few_blinded_hops(void);
45582 export function SendError_too_few_blinded_hops(): bigint {
45583 if(!isWasmInitialized) {
45584 throw new Error("initializeWasm() must be awaited first!");
45586 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
45587 return nativeResponseValue;
45589 // struct LDKSendError SendError_invalid_first_hop(void);
45591 export function SendError_invalid_first_hop(): bigint {
45592 if(!isWasmInitialized) {
45593 throw new Error("initializeWasm() must be awaited first!");
45595 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
45596 return nativeResponseValue;
45598 // struct LDKSendError SendError_invalid_message(void);
45600 export function SendError_invalid_message(): bigint {
45601 if(!isWasmInitialized) {
45602 throw new Error("initializeWasm() must be awaited first!");
45604 const nativeResponseValue = wasm.TS_SendError_invalid_message();
45605 return nativeResponseValue;
45607 // struct LDKSendError SendError_buffer_full(void);
45609 export function SendError_buffer_full(): bigint {
45610 if(!isWasmInitialized) {
45611 throw new Error("initializeWasm() must be awaited first!");
45613 const nativeResponseValue = wasm.TS_SendError_buffer_full();
45614 return nativeResponseValue;
45616 // struct LDKSendError SendError_get_node_id_failed(void);
45618 export function SendError_get_node_id_failed(): bigint {
45619 if(!isWasmInitialized) {
45620 throw new Error("initializeWasm() must be awaited first!");
45622 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
45623 return nativeResponseValue;
45625 // struct LDKSendError SendError_blinded_path_advance_failed(void);
45627 export function SendError_blinded_path_advance_failed(): bigint {
45628 if(!isWasmInitialized) {
45629 throw new Error("initializeWasm() must be awaited first!");
45631 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
45632 return nativeResponseValue;
45634 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
45636 export function SendError_eq(a: bigint, b: bigint): boolean {
45637 if(!isWasmInitialized) {
45638 throw new Error("initializeWasm() must be awaited first!");
45640 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
45641 return nativeResponseValue;
45643 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
45645 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
45646 if(!isWasmInitialized) {
45647 throw new Error("initializeWasm() must be awaited first!");
45649 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
45650 // debug statements here
45652 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKMessageRouter message_router, struct LDKOffersMessageHandler offers_handler, struct LDKCustomOnionMessageHandler custom_handler);
45654 export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, message_router: bigint, offers_handler: bigint, custom_handler: bigint): bigint {
45655 if(!isWasmInitialized) {
45656 throw new Error("initializeWasm() must be awaited first!");
45658 const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, message_router, offers_handler, custom_handler);
45659 return nativeResponseValue;
45661 // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKOnionMessagePath path, struct LDKOnionMessageContents message, struct LDKBlindedPath reply_path);
45663 export function OnionMessenger_send_onion_message(this_arg: bigint, path: bigint, message: bigint, reply_path: bigint): bigint {
45664 if(!isWasmInitialized) {
45665 throw new Error("initializeWasm() must be awaited first!");
45667 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, path, message, reply_path);
45668 return nativeResponseValue;
45670 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
45672 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
45673 if(!isWasmInitialized) {
45674 throw new Error("initializeWasm() must be awaited first!");
45676 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
45677 return nativeResponseValue;
45679 // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
45681 export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
45682 if(!isWasmInitialized) {
45683 throw new Error("initializeWasm() must be awaited first!");
45685 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
45686 return nativeResponseValue;
45688 // void OffersMessageHandler_free(struct LDKOffersMessageHandler this_ptr);
45690 export function OffersMessageHandler_free(this_ptr: bigint): void {
45691 if(!isWasmInitialized) {
45692 throw new Error("initializeWasm() must be awaited first!");
45694 const nativeResponseValue = wasm.TS_OffersMessageHandler_free(this_ptr);
45695 // debug statements here
45697 // void OffersMessage_free(struct LDKOffersMessage this_ptr);
45699 export function OffersMessage_free(this_ptr: bigint): void {
45700 if(!isWasmInitialized) {
45701 throw new Error("initializeWasm() must be awaited first!");
45703 const nativeResponseValue = wasm.TS_OffersMessage_free(this_ptr);
45704 // debug statements here
45706 // uint64_t OffersMessage_clone_ptr(LDKOffersMessage *NONNULL_PTR arg);
45708 export function OffersMessage_clone_ptr(arg: bigint): bigint {
45709 if(!isWasmInitialized) {
45710 throw new Error("initializeWasm() must be awaited first!");
45712 const nativeResponseValue = wasm.TS_OffersMessage_clone_ptr(arg);
45713 return nativeResponseValue;
45715 // struct LDKOffersMessage OffersMessage_clone(const struct LDKOffersMessage *NONNULL_PTR orig);
45717 export function OffersMessage_clone(orig: bigint): bigint {
45718 if(!isWasmInitialized) {
45719 throw new Error("initializeWasm() must be awaited first!");
45721 const nativeResponseValue = wasm.TS_OffersMessage_clone(orig);
45722 return nativeResponseValue;
45724 // struct LDKOffersMessage OffersMessage_invoice_request(struct LDKInvoiceRequest a);
45726 export function OffersMessage_invoice_request(a: bigint): bigint {
45727 if(!isWasmInitialized) {
45728 throw new Error("initializeWasm() must be awaited first!");
45730 const nativeResponseValue = wasm.TS_OffersMessage_invoice_request(a);
45731 return nativeResponseValue;
45733 // struct LDKOffersMessage OffersMessage_invoice(struct LDKBolt12Invoice a);
45735 export function OffersMessage_invoice(a: bigint): bigint {
45736 if(!isWasmInitialized) {
45737 throw new Error("initializeWasm() must be awaited first!");
45739 const nativeResponseValue = wasm.TS_OffersMessage_invoice(a);
45740 return nativeResponseValue;
45742 // struct LDKOffersMessage OffersMessage_invoice_error(struct LDKInvoiceError a);
45744 export function OffersMessage_invoice_error(a: bigint): bigint {
45745 if(!isWasmInitialized) {
45746 throw new Error("initializeWasm() must be awaited first!");
45748 const nativeResponseValue = wasm.TS_OffersMessage_invoice_error(a);
45749 return nativeResponseValue;
45751 // MUST_USE_RES bool OffersMessage_is_known_type(uint64_t tlv_type);
45753 export function OffersMessage_is_known_type(tlv_type: bigint): boolean {
45754 if(!isWasmInitialized) {
45755 throw new Error("initializeWasm() must be awaited first!");
45757 const nativeResponseValue = wasm.TS_OffersMessage_is_known_type(tlv_type);
45758 return nativeResponseValue;
45760 // MUST_USE_RES uint64_t OffersMessage_tlv_type(const struct LDKOffersMessage *NONNULL_PTR this_arg);
45762 export function OffersMessage_tlv_type(this_arg: bigint): bigint {
45763 if(!isWasmInitialized) {
45764 throw new Error("initializeWasm() must be awaited first!");
45766 const nativeResponseValue = wasm.TS_OffersMessage_tlv_type(this_arg);
45767 return nativeResponseValue;
45769 // struct LDKCVec_u8Z OffersMessage_write(const struct LDKOffersMessage *NONNULL_PTR obj);
45771 export function OffersMessage_write(obj: bigint): number {
45772 if(!isWasmInitialized) {
45773 throw new Error("initializeWasm() must be awaited first!");
45775 const nativeResponseValue = wasm.TS_OffersMessage_write(obj);
45776 return nativeResponseValue;
45778 // struct LDKCResult_OffersMessageDecodeErrorZ OffersMessage_read(struct LDKu8slice ser, uint64_t arg_a, const struct LDKLogger *NONNULL_PTR arg_b);
45780 export function OffersMessage_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
45781 if(!isWasmInitialized) {
45782 throw new Error("initializeWasm() must be awaited first!");
45784 const nativeResponseValue = wasm.TS_OffersMessage_read(ser, arg_a, arg_b);
45785 return nativeResponseValue;
45787 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
45789 export function OnionMessageContents_free(this_ptr: bigint): void {
45790 if(!isWasmInitialized) {
45791 throw new Error("initializeWasm() must be awaited first!");
45793 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
45794 // debug statements here
45796 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
45798 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
45799 if(!isWasmInitialized) {
45800 throw new Error("initializeWasm() must be awaited first!");
45802 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
45803 return nativeResponseValue;
45805 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
45807 export function OnionMessageContents_clone(orig: bigint): bigint {
45808 if(!isWasmInitialized) {
45809 throw new Error("initializeWasm() must be awaited first!");
45811 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
45812 return nativeResponseValue;
45814 // struct LDKOnionMessageContents OnionMessageContents_offers(struct LDKOffersMessage a);
45816 export function OnionMessageContents_offers(a: bigint): bigint {
45817 if(!isWasmInitialized) {
45818 throw new Error("initializeWasm() must be awaited first!");
45820 const nativeResponseValue = wasm.TS_OnionMessageContents_offers(a);
45821 return nativeResponseValue;
45823 // struct LDKOnionMessageContents OnionMessageContents_custom(struct LDKCustomOnionMessageContents a);
45825 export function OnionMessageContents_custom(a: bigint): bigint {
45826 if(!isWasmInitialized) {
45827 throw new Error("initializeWasm() must be awaited first!");
45829 const nativeResponseValue = wasm.TS_OnionMessageContents_custom(a);
45830 return nativeResponseValue;
45832 // uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
45834 export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
45835 if(!isWasmInitialized) {
45836 throw new Error("initializeWasm() must be awaited first!");
45838 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
45839 return nativeResponseValue;
45841 // struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
45843 export function CustomOnionMessageContents_clone(orig: bigint): bigint {
45844 if(!isWasmInitialized) {
45845 throw new Error("initializeWasm() must be awaited first!");
45847 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
45848 return nativeResponseValue;
45850 // void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
45852 export function CustomOnionMessageContents_free(this_ptr: bigint): void {
45853 if(!isWasmInitialized) {
45854 throw new Error("initializeWasm() must be awaited first!");
45856 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
45857 // debug statements here
45859 // void BlindedPath_free(struct LDKBlindedPath this_obj);
45861 export function BlindedPath_free(this_obj: bigint): void {
45862 if(!isWasmInitialized) {
45863 throw new Error("initializeWasm() must be awaited first!");
45865 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
45866 // debug statements here
45868 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
45870 export function BlindedPath_clone_ptr(arg: bigint): bigint {
45871 if(!isWasmInitialized) {
45872 throw new Error("initializeWasm() must be awaited first!");
45874 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
45875 return nativeResponseValue;
45877 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
45879 export function BlindedPath_clone(orig: bigint): bigint {
45880 if(!isWasmInitialized) {
45881 throw new Error("initializeWasm() must be awaited first!");
45883 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
45884 return nativeResponseValue;
45886 // uint64_t BlindedPath_hash(const struct LDKBlindedPath *NONNULL_PTR o);
45888 export function BlindedPath_hash(o: bigint): bigint {
45889 if(!isWasmInitialized) {
45890 throw new Error("initializeWasm() must be awaited first!");
45892 const nativeResponseValue = wasm.TS_BlindedPath_hash(o);
45893 return nativeResponseValue;
45895 // bool BlindedPath_eq(const struct LDKBlindedPath *NONNULL_PTR a, const struct LDKBlindedPath *NONNULL_PTR b);
45897 export function BlindedPath_eq(a: bigint, b: bigint): boolean {
45898 if(!isWasmInitialized) {
45899 throw new Error("initializeWasm() must be awaited first!");
45901 const nativeResponseValue = wasm.TS_BlindedPath_eq(a, b);
45902 return nativeResponseValue;
45904 // void BlindedHop_free(struct LDKBlindedHop this_obj);
45906 export function BlindedHop_free(this_obj: bigint): void {
45907 if(!isWasmInitialized) {
45908 throw new Error("initializeWasm() must be awaited first!");
45910 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
45911 // debug statements here
45913 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
45915 export function BlindedHop_clone_ptr(arg: bigint): bigint {
45916 if(!isWasmInitialized) {
45917 throw new Error("initializeWasm() must be awaited first!");
45919 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
45920 return nativeResponseValue;
45922 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
45924 export function BlindedHop_clone(orig: bigint): bigint {
45925 if(!isWasmInitialized) {
45926 throw new Error("initializeWasm() must be awaited first!");
45928 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
45929 return nativeResponseValue;
45931 // uint64_t BlindedHop_hash(const struct LDKBlindedHop *NONNULL_PTR o);
45933 export function BlindedHop_hash(o: bigint): bigint {
45934 if(!isWasmInitialized) {
45935 throw new Error("initializeWasm() must be awaited first!");
45937 const nativeResponseValue = wasm.TS_BlindedHop_hash(o);
45938 return nativeResponseValue;
45940 // bool BlindedHop_eq(const struct LDKBlindedHop *NONNULL_PTR a, const struct LDKBlindedHop *NONNULL_PTR b);
45942 export function BlindedHop_eq(a: bigint, b: bigint): boolean {
45943 if(!isWasmInitialized) {
45944 throw new Error("initializeWasm() must be awaited first!");
45946 const nativeResponseValue = wasm.TS_BlindedHop_eq(a, b);
45947 return nativeResponseValue;
45949 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new_for_message(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
45951 export function BlindedPath_new_for_message(node_pks: number, entropy_source: bigint): bigint {
45952 if(!isWasmInitialized) {
45953 throw new Error("initializeWasm() must be awaited first!");
45955 const nativeResponseValue = wasm.TS_BlindedPath_new_for_message(node_pks, entropy_source);
45956 return nativeResponseValue;
45958 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
45960 export function BlindedPath_write(obj: bigint): number {
45961 if(!isWasmInitialized) {
45962 throw new Error("initializeWasm() must be awaited first!");
45964 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
45965 return nativeResponseValue;
45967 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
45969 export function BlindedPath_read(ser: number): bigint {
45970 if(!isWasmInitialized) {
45971 throw new Error("initializeWasm() must be awaited first!");
45973 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
45974 return nativeResponseValue;
45976 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
45978 export function BlindedHop_write(obj: bigint): number {
45979 if(!isWasmInitialized) {
45980 throw new Error("initializeWasm() must be awaited first!");
45982 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
45983 return nativeResponseValue;
45985 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
45987 export function BlindedHop_read(ser: number): bigint {
45988 if(!isWasmInitialized) {
45989 throw new Error("initializeWasm() must be awaited first!");
45991 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
45992 return nativeResponseValue;
45994 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
45996 export function PaymentPurpose_free(this_ptr: bigint): void {
45997 if(!isWasmInitialized) {
45998 throw new Error("initializeWasm() must be awaited first!");
46000 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
46001 // debug statements here
46003 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
46005 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
46006 if(!isWasmInitialized) {
46007 throw new Error("initializeWasm() must be awaited first!");
46009 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
46010 return nativeResponseValue;
46012 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
46014 export function PaymentPurpose_clone(orig: bigint): bigint {
46015 if(!isWasmInitialized) {
46016 throw new Error("initializeWasm() must be awaited first!");
46018 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
46019 return nativeResponseValue;
46021 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKCOption_PaymentPreimageZ payment_preimage, struct LDKThirtyTwoBytes payment_secret);
46023 export function PaymentPurpose_invoice_payment(payment_preimage: bigint, payment_secret: number): bigint {
46024 if(!isWasmInitialized) {
46025 throw new Error("initializeWasm() must be awaited first!");
46027 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
46028 return nativeResponseValue;
46030 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
46032 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
46033 if(!isWasmInitialized) {
46034 throw new Error("initializeWasm() must be awaited first!");
46036 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
46037 return nativeResponseValue;
46039 // bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
46041 export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
46042 if(!isWasmInitialized) {
46043 throw new Error("initializeWasm() must be awaited first!");
46045 const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
46046 return nativeResponseValue;
46048 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
46050 export function PaymentPurpose_write(obj: bigint): number {
46051 if(!isWasmInitialized) {
46052 throw new Error("initializeWasm() must be awaited first!");
46054 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
46055 return nativeResponseValue;
46057 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
46059 export function PaymentPurpose_read(ser: number): bigint {
46060 if(!isWasmInitialized) {
46061 throw new Error("initializeWasm() must be awaited first!");
46063 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
46064 return nativeResponseValue;
46066 // void PathFailure_free(struct LDKPathFailure this_ptr);
46068 export function PathFailure_free(this_ptr: bigint): void {
46069 if(!isWasmInitialized) {
46070 throw new Error("initializeWasm() must be awaited first!");
46072 const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
46073 // debug statements here
46075 // uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
46077 export function PathFailure_clone_ptr(arg: bigint): bigint {
46078 if(!isWasmInitialized) {
46079 throw new Error("initializeWasm() must be awaited first!");
46081 const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
46082 return nativeResponseValue;
46084 // struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
46086 export function PathFailure_clone(orig: bigint): bigint {
46087 if(!isWasmInitialized) {
46088 throw new Error("initializeWasm() must be awaited first!");
46090 const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
46091 return nativeResponseValue;
46093 // struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
46095 export function PathFailure_initial_send(err: bigint): bigint {
46096 if(!isWasmInitialized) {
46097 throw new Error("initializeWasm() must be awaited first!");
46099 const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
46100 return nativeResponseValue;
46102 // struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
46104 export function PathFailure_on_path(network_update: bigint): bigint {
46105 if(!isWasmInitialized) {
46106 throw new Error("initializeWasm() must be awaited first!");
46108 const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
46109 return nativeResponseValue;
46111 // bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
46113 export function PathFailure_eq(a: bigint, b: bigint): boolean {
46114 if(!isWasmInitialized) {
46115 throw new Error("initializeWasm() must be awaited first!");
46117 const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
46118 return nativeResponseValue;
46120 // struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
46122 export function PathFailure_write(obj: bigint): number {
46123 if(!isWasmInitialized) {
46124 throw new Error("initializeWasm() must be awaited first!");
46126 const nativeResponseValue = wasm.TS_PathFailure_write(obj);
46127 return nativeResponseValue;
46129 // struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
46131 export function PathFailure_read(ser: number): bigint {
46132 if(!isWasmInitialized) {
46133 throw new Error("initializeWasm() must be awaited first!");
46135 const nativeResponseValue = wasm.TS_PathFailure_read(ser);
46136 return nativeResponseValue;
46138 // void ClosureReason_free(struct LDKClosureReason this_ptr);
46140 export function ClosureReason_free(this_ptr: bigint): void {
46141 if(!isWasmInitialized) {
46142 throw new Error("initializeWasm() must be awaited first!");
46144 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
46145 // debug statements here
46147 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
46149 export function ClosureReason_clone_ptr(arg: bigint): bigint {
46150 if(!isWasmInitialized) {
46151 throw new Error("initializeWasm() must be awaited first!");
46153 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
46154 return nativeResponseValue;
46156 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
46158 export function ClosureReason_clone(orig: bigint): bigint {
46159 if(!isWasmInitialized) {
46160 throw new Error("initializeWasm() must be awaited first!");
46162 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
46163 return nativeResponseValue;
46165 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKUntrustedString peer_msg);
46167 export function ClosureReason_counterparty_force_closed(peer_msg: bigint): bigint {
46168 if(!isWasmInitialized) {
46169 throw new Error("initializeWasm() must be awaited first!");
46171 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
46172 return nativeResponseValue;
46174 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
46176 export function ClosureReason_holder_force_closed(): bigint {
46177 if(!isWasmInitialized) {
46178 throw new Error("initializeWasm() must be awaited first!");
46180 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
46181 return nativeResponseValue;
46183 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
46185 export function ClosureReason_cooperative_closure(): bigint {
46186 if(!isWasmInitialized) {
46187 throw new Error("initializeWasm() must be awaited first!");
46189 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
46190 return nativeResponseValue;
46192 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
46194 export function ClosureReason_commitment_tx_confirmed(): bigint {
46195 if(!isWasmInitialized) {
46196 throw new Error("initializeWasm() must be awaited first!");
46198 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
46199 return nativeResponseValue;
46201 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
46203 export function ClosureReason_funding_timed_out(): bigint {
46204 if(!isWasmInitialized) {
46205 throw new Error("initializeWasm() must be awaited first!");
46207 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
46208 return nativeResponseValue;
46210 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
46212 export function ClosureReason_processing_error(err: number): bigint {
46213 if(!isWasmInitialized) {
46214 throw new Error("initializeWasm() must be awaited first!");
46216 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
46217 return nativeResponseValue;
46219 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
46221 export function ClosureReason_disconnected_peer(): bigint {
46222 if(!isWasmInitialized) {
46223 throw new Error("initializeWasm() must be awaited first!");
46225 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
46226 return nativeResponseValue;
46228 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
46230 export function ClosureReason_outdated_channel_manager(): bigint {
46231 if(!isWasmInitialized) {
46232 throw new Error("initializeWasm() must be awaited first!");
46234 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
46235 return nativeResponseValue;
46237 // struct LDKClosureReason ClosureReason_counterparty_coop_closed_unfunded_channel(void);
46239 export function ClosureReason_counterparty_coop_closed_unfunded_channel(): bigint {
46240 if(!isWasmInitialized) {
46241 throw new Error("initializeWasm() must be awaited first!");
46243 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_coop_closed_unfunded_channel();
46244 return nativeResponseValue;
46246 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
46248 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
46249 if(!isWasmInitialized) {
46250 throw new Error("initializeWasm() must be awaited first!");
46252 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
46253 return nativeResponseValue;
46255 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
46257 export function ClosureReason_write(obj: bigint): number {
46258 if(!isWasmInitialized) {
46259 throw new Error("initializeWasm() must be awaited first!");
46261 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
46262 return nativeResponseValue;
46264 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
46266 export function ClosureReason_read(ser: number): bigint {
46267 if(!isWasmInitialized) {
46268 throw new Error("initializeWasm() must be awaited first!");
46270 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
46271 return nativeResponseValue;
46273 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
46275 export function HTLCDestination_free(this_ptr: bigint): void {
46276 if(!isWasmInitialized) {
46277 throw new Error("initializeWasm() must be awaited first!");
46279 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
46280 // debug statements here
46282 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
46284 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
46285 if(!isWasmInitialized) {
46286 throw new Error("initializeWasm() must be awaited first!");
46288 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
46289 return nativeResponseValue;
46291 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
46293 export function HTLCDestination_clone(orig: bigint): bigint {
46294 if(!isWasmInitialized) {
46295 throw new Error("initializeWasm() must be awaited first!");
46297 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
46298 return nativeResponseValue;
46300 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
46302 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
46303 if(!isWasmInitialized) {
46304 throw new Error("initializeWasm() must be awaited first!");
46306 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
46307 return nativeResponseValue;
46309 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
46311 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
46312 if(!isWasmInitialized) {
46313 throw new Error("initializeWasm() must be awaited first!");
46315 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
46316 return nativeResponseValue;
46318 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
46320 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
46321 if(!isWasmInitialized) {
46322 throw new Error("initializeWasm() must be awaited first!");
46324 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
46325 return nativeResponseValue;
46327 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
46329 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
46330 if(!isWasmInitialized) {
46331 throw new Error("initializeWasm() must be awaited first!");
46333 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
46334 return nativeResponseValue;
46336 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
46338 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
46339 if(!isWasmInitialized) {
46340 throw new Error("initializeWasm() must be awaited first!");
46342 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
46343 return nativeResponseValue;
46345 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
46347 export function HTLCDestination_write(obj: bigint): number {
46348 if(!isWasmInitialized) {
46349 throw new Error("initializeWasm() must be awaited first!");
46351 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
46352 return nativeResponseValue;
46354 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
46356 export function HTLCDestination_read(ser: number): bigint {
46357 if(!isWasmInitialized) {
46358 throw new Error("initializeWasm() must be awaited first!");
46360 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
46361 return nativeResponseValue;
46363 // enum LDKPaymentFailureReason PaymentFailureReason_clone(const enum LDKPaymentFailureReason *NONNULL_PTR orig);
46365 export function PaymentFailureReason_clone(orig: bigint): PaymentFailureReason {
46366 if(!isWasmInitialized) {
46367 throw new Error("initializeWasm() must be awaited first!");
46369 const nativeResponseValue = wasm.TS_PaymentFailureReason_clone(orig);
46370 return nativeResponseValue;
46372 // enum LDKPaymentFailureReason PaymentFailureReason_recipient_rejected(void);
46374 export function PaymentFailureReason_recipient_rejected(): PaymentFailureReason {
46375 if(!isWasmInitialized) {
46376 throw new Error("initializeWasm() must be awaited first!");
46378 const nativeResponseValue = wasm.TS_PaymentFailureReason_recipient_rejected();
46379 return nativeResponseValue;
46381 // enum LDKPaymentFailureReason PaymentFailureReason_user_abandoned(void);
46383 export function PaymentFailureReason_user_abandoned(): PaymentFailureReason {
46384 if(!isWasmInitialized) {
46385 throw new Error("initializeWasm() must be awaited first!");
46387 const nativeResponseValue = wasm.TS_PaymentFailureReason_user_abandoned();
46388 return nativeResponseValue;
46390 // enum LDKPaymentFailureReason PaymentFailureReason_retries_exhausted(void);
46392 export function PaymentFailureReason_retries_exhausted(): PaymentFailureReason {
46393 if(!isWasmInitialized) {
46394 throw new Error("initializeWasm() must be awaited first!");
46396 const nativeResponseValue = wasm.TS_PaymentFailureReason_retries_exhausted();
46397 return nativeResponseValue;
46399 // enum LDKPaymentFailureReason PaymentFailureReason_payment_expired(void);
46401 export function PaymentFailureReason_payment_expired(): PaymentFailureReason {
46402 if(!isWasmInitialized) {
46403 throw new Error("initializeWasm() must be awaited first!");
46405 const nativeResponseValue = wasm.TS_PaymentFailureReason_payment_expired();
46406 return nativeResponseValue;
46408 // enum LDKPaymentFailureReason PaymentFailureReason_route_not_found(void);
46410 export function PaymentFailureReason_route_not_found(): PaymentFailureReason {
46411 if(!isWasmInitialized) {
46412 throw new Error("initializeWasm() must be awaited first!");
46414 const nativeResponseValue = wasm.TS_PaymentFailureReason_route_not_found();
46415 return nativeResponseValue;
46417 // enum LDKPaymentFailureReason PaymentFailureReason_unexpected_error(void);
46419 export function PaymentFailureReason_unexpected_error(): PaymentFailureReason {
46420 if(!isWasmInitialized) {
46421 throw new Error("initializeWasm() must be awaited first!");
46423 const nativeResponseValue = wasm.TS_PaymentFailureReason_unexpected_error();
46424 return nativeResponseValue;
46426 // bool PaymentFailureReason_eq(const enum LDKPaymentFailureReason *NONNULL_PTR a, const enum LDKPaymentFailureReason *NONNULL_PTR b);
46428 export function PaymentFailureReason_eq(a: bigint, b: bigint): boolean {
46429 if(!isWasmInitialized) {
46430 throw new Error("initializeWasm() must be awaited first!");
46432 const nativeResponseValue = wasm.TS_PaymentFailureReason_eq(a, b);
46433 return nativeResponseValue;
46435 // struct LDKCVec_u8Z PaymentFailureReason_write(const enum LDKPaymentFailureReason *NONNULL_PTR obj);
46437 export function PaymentFailureReason_write(obj: bigint): number {
46438 if(!isWasmInitialized) {
46439 throw new Error("initializeWasm() must be awaited first!");
46441 const nativeResponseValue = wasm.TS_PaymentFailureReason_write(obj);
46442 return nativeResponseValue;
46444 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ PaymentFailureReason_read(struct LDKu8slice ser);
46446 export function PaymentFailureReason_read(ser: number): bigint {
46447 if(!isWasmInitialized) {
46448 throw new Error("initializeWasm() must be awaited first!");
46450 const nativeResponseValue = wasm.TS_PaymentFailureReason_read(ser);
46451 return nativeResponseValue;
46453 // void Event_free(struct LDKEvent this_ptr);
46455 export function Event_free(this_ptr: bigint): void {
46456 if(!isWasmInitialized) {
46457 throw new Error("initializeWasm() must be awaited first!");
46459 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
46460 // debug statements here
46462 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
46464 export function Event_clone_ptr(arg: bigint): bigint {
46465 if(!isWasmInitialized) {
46466 throw new Error("initializeWasm() must be awaited first!");
46468 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
46469 return nativeResponseValue;
46471 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
46473 export function Event_clone(orig: bigint): bigint {
46474 if(!isWasmInitialized) {
46475 throw new Error("initializeWasm() must be awaited first!");
46477 const nativeResponseValue = wasm.TS_Event_clone(orig);
46478 return nativeResponseValue;
46480 // 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);
46482 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 {
46483 if(!isWasmInitialized) {
46484 throw new Error("initializeWasm() must be awaited first!");
46486 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
46487 return nativeResponseValue;
46489 // struct LDKEvent Event_payment_claimable(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields onion_fields, uint64_t amount_msat, uint64_t counterparty_skimmed_fee_msat, struct LDKPaymentPurpose purpose, struct LDKThirtyTwoBytes via_channel_id, struct LDKCOption_u128Z via_user_channel_id, struct LDKCOption_u32Z claim_deadline);
46491 export function Event_payment_claimable(receiver_node_id: number, payment_hash: number, onion_fields: bigint, amount_msat: bigint, counterparty_skimmed_fee_msat: bigint, purpose: bigint, via_channel_id: number, via_user_channel_id: bigint, claim_deadline: bigint): bigint {
46492 if(!isWasmInitialized) {
46493 throw new Error("initializeWasm() must be awaited first!");
46495 const nativeResponseValue = wasm.TS_Event_payment_claimable(receiver_node_id, payment_hash, onion_fields, amount_msat, counterparty_skimmed_fee_msat, purpose, via_channel_id, via_user_channel_id, claim_deadline);
46496 return nativeResponseValue;
46498 // struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
46500 export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
46501 if(!isWasmInitialized) {
46502 throw new Error("initializeWasm() must be awaited first!");
46504 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose);
46505 return nativeResponseValue;
46507 // struct LDKEvent Event_payment_sent(struct LDKCOption_PaymentIdZ payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
46509 export function Event_payment_sent(payment_id: bigint, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
46510 if(!isWasmInitialized) {
46511 throw new Error("initializeWasm() must be awaited first!");
46513 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
46514 return nativeResponseValue;
46516 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_PaymentFailureReasonZ reason);
46518 export function Event_payment_failed(payment_id: number, payment_hash: number, reason: bigint): bigint {
46519 if(!isWasmInitialized) {
46520 throw new Error("initializeWasm() must be awaited first!");
46522 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash, reason);
46523 return nativeResponseValue;
46525 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_PaymentHashZ payment_hash, struct LDKPath path);
46527 export function Event_payment_path_successful(payment_id: number, payment_hash: bigint, path: bigint): bigint {
46528 if(!isWasmInitialized) {
46529 throw new Error("initializeWasm() must be awaited first!");
46531 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
46532 return nativeResponseValue;
46534 // struct LDKEvent Event_payment_path_failed(struct LDKCOption_PaymentIdZ payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKPathFailure failure, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
46536 export function Event_payment_path_failed(payment_id: bigint, payment_hash: number, payment_failed_permanently: boolean, failure: bigint, path: bigint, short_channel_id: bigint): bigint {
46537 if(!isWasmInitialized) {
46538 throw new Error("initializeWasm() must be awaited first!");
46540 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id);
46541 return nativeResponseValue;
46543 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
46545 export function Event_probe_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
46546 if(!isWasmInitialized) {
46547 throw new Error("initializeWasm() must be awaited first!");
46549 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
46550 return nativeResponseValue;
46552 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
46554 export function Event_probe_failed(payment_id: number, payment_hash: number, path: bigint, short_channel_id: bigint): bigint {
46555 if(!isWasmInitialized) {
46556 throw new Error("initializeWasm() must be awaited first!");
46558 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
46559 return nativeResponseValue;
46561 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
46563 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
46564 if(!isWasmInitialized) {
46565 throw new Error("initializeWasm() must be awaited first!");
46567 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
46568 return nativeResponseValue;
46570 // 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);
46572 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 {
46573 if(!isWasmInitialized) {
46574 throw new Error("initializeWasm() must be awaited first!");
46576 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
46577 return nativeResponseValue;
46579 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
46581 export function Event_spendable_outputs(outputs: number): bigint {
46582 if(!isWasmInitialized) {
46583 throw new Error("initializeWasm() must be awaited first!");
46585 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
46586 return nativeResponseValue;
46588 // 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, struct LDKCOption_u64Z outbound_amount_forwarded_msat);
46590 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean, outbound_amount_forwarded_msat: bigint): bigint {
46591 if(!isWasmInitialized) {
46592 throw new Error("initializeWasm() must be awaited first!");
46594 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx, outbound_amount_forwarded_msat);
46595 return nativeResponseValue;
46597 // struct LDKEvent Event_channel_pending(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKThirtyTwoBytes former_temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKOutPoint funding_txo);
46599 export function Event_channel_pending(channel_id: number, user_channel_id: number, former_temporary_channel_id: number, counterparty_node_id: number, funding_txo: bigint): bigint {
46600 if(!isWasmInitialized) {
46601 throw new Error("initializeWasm() must be awaited first!");
46603 const nativeResponseValue = wasm.TS_Event_channel_pending(channel_id, user_channel_id, former_temporary_channel_id, counterparty_node_id, funding_txo);
46604 return nativeResponseValue;
46606 // struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
46608 export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
46609 if(!isWasmInitialized) {
46610 throw new Error("initializeWasm() must be awaited first!");
46612 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
46613 return nativeResponseValue;
46615 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason);
46617 export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint): bigint {
46618 if(!isWasmInitialized) {
46619 throw new Error("initializeWasm() must be awaited first!");
46621 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
46622 return nativeResponseValue;
46624 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
46626 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
46627 if(!isWasmInitialized) {
46628 throw new Error("initializeWasm() must be awaited first!");
46630 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
46631 return nativeResponseValue;
46633 // 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);
46635 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
46636 if(!isWasmInitialized) {
46637 throw new Error("initializeWasm() must be awaited first!");
46639 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
46640 return nativeResponseValue;
46642 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
46644 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
46645 if(!isWasmInitialized) {
46646 throw new Error("initializeWasm() must be awaited first!");
46648 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
46649 return nativeResponseValue;
46651 // struct LDKEvent Event_bump_transaction(struct LDKBumpTransactionEvent a);
46653 export function Event_bump_transaction(a: bigint): bigint {
46654 if(!isWasmInitialized) {
46655 throw new Error("initializeWasm() must be awaited first!");
46657 const nativeResponseValue = wasm.TS_Event_bump_transaction(a);
46658 return nativeResponseValue;
46660 // bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
46662 export function Event_eq(a: bigint, b: bigint): boolean {
46663 if(!isWasmInitialized) {
46664 throw new Error("initializeWasm() must be awaited first!");
46666 const nativeResponseValue = wasm.TS_Event_eq(a, b);
46667 return nativeResponseValue;
46669 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
46671 export function Event_write(obj: bigint): number {
46672 if(!isWasmInitialized) {
46673 throw new Error("initializeWasm() must be awaited first!");
46675 const nativeResponseValue = wasm.TS_Event_write(obj);
46676 return nativeResponseValue;
46678 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
46680 export function Event_read(ser: number): bigint {
46681 if(!isWasmInitialized) {
46682 throw new Error("initializeWasm() must be awaited first!");
46684 const nativeResponseValue = wasm.TS_Event_read(ser);
46685 return nativeResponseValue;
46687 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
46689 export function MessageSendEvent_free(this_ptr: bigint): void {
46690 if(!isWasmInitialized) {
46691 throw new Error("initializeWasm() must be awaited first!");
46693 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
46694 // debug statements here
46696 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
46698 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
46699 if(!isWasmInitialized) {
46700 throw new Error("initializeWasm() must be awaited first!");
46702 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
46703 return nativeResponseValue;
46705 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
46707 export function MessageSendEvent_clone(orig: bigint): bigint {
46708 if(!isWasmInitialized) {
46709 throw new Error("initializeWasm() must be awaited first!");
46711 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
46712 return nativeResponseValue;
46714 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
46716 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
46717 if(!isWasmInitialized) {
46718 throw new Error("initializeWasm() must be awaited first!");
46720 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
46721 return nativeResponseValue;
46723 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel_v2(struct LDKPublicKey node_id, struct LDKAcceptChannelV2 msg);
46725 export function MessageSendEvent_send_accept_channel_v2(node_id: number, msg: bigint): bigint {
46726 if(!isWasmInitialized) {
46727 throw new Error("initializeWasm() must be awaited first!");
46729 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel_v2(node_id, msg);
46730 return nativeResponseValue;
46732 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
46734 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
46735 if(!isWasmInitialized) {
46736 throw new Error("initializeWasm() must be awaited first!");
46738 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
46739 return nativeResponseValue;
46741 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel_v2(struct LDKPublicKey node_id, struct LDKOpenChannelV2 msg);
46743 export function MessageSendEvent_send_open_channel_v2(node_id: number, msg: bigint): bigint {
46744 if(!isWasmInitialized) {
46745 throw new Error("initializeWasm() must be awaited first!");
46747 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel_v2(node_id, msg);
46748 return nativeResponseValue;
46750 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
46752 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
46753 if(!isWasmInitialized) {
46754 throw new Error("initializeWasm() must be awaited first!");
46756 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
46757 return nativeResponseValue;
46759 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
46761 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
46762 if(!isWasmInitialized) {
46763 throw new Error("initializeWasm() must be awaited first!");
46765 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
46766 return nativeResponseValue;
46768 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_input(struct LDKPublicKey node_id, struct LDKTxAddInput msg);
46770 export function MessageSendEvent_send_tx_add_input(node_id: number, msg: bigint): bigint {
46771 if(!isWasmInitialized) {
46772 throw new Error("initializeWasm() must be awaited first!");
46774 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_input(node_id, msg);
46775 return nativeResponseValue;
46777 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_output(struct LDKPublicKey node_id, struct LDKTxAddOutput msg);
46779 export function MessageSendEvent_send_tx_add_output(node_id: number, msg: bigint): bigint {
46780 if(!isWasmInitialized) {
46781 throw new Error("initializeWasm() must be awaited first!");
46783 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_output(node_id, msg);
46784 return nativeResponseValue;
46786 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_input(struct LDKPublicKey node_id, struct LDKTxRemoveInput msg);
46788 export function MessageSendEvent_send_tx_remove_input(node_id: number, msg: bigint): bigint {
46789 if(!isWasmInitialized) {
46790 throw new Error("initializeWasm() must be awaited first!");
46792 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_input(node_id, msg);
46793 return nativeResponseValue;
46795 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_output(struct LDKPublicKey node_id, struct LDKTxRemoveOutput msg);
46797 export function MessageSendEvent_send_tx_remove_output(node_id: number, msg: bigint): bigint {
46798 if(!isWasmInitialized) {
46799 throw new Error("initializeWasm() must be awaited first!");
46801 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_output(node_id, msg);
46802 return nativeResponseValue;
46804 // struct LDKMessageSendEvent MessageSendEvent_send_tx_complete(struct LDKPublicKey node_id, struct LDKTxComplete msg);
46806 export function MessageSendEvent_send_tx_complete(node_id: number, msg: bigint): bigint {
46807 if(!isWasmInitialized) {
46808 throw new Error("initializeWasm() must be awaited first!");
46810 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_complete(node_id, msg);
46811 return nativeResponseValue;
46813 // struct LDKMessageSendEvent MessageSendEvent_send_tx_signatures(struct LDKPublicKey node_id, struct LDKTxSignatures msg);
46815 export function MessageSendEvent_send_tx_signatures(node_id: number, msg: bigint): bigint {
46816 if(!isWasmInitialized) {
46817 throw new Error("initializeWasm() must be awaited first!");
46819 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_signatures(node_id, msg);
46820 return nativeResponseValue;
46822 // struct LDKMessageSendEvent MessageSendEvent_send_tx_init_rbf(struct LDKPublicKey node_id, struct LDKTxInitRbf msg);
46824 export function MessageSendEvent_send_tx_init_rbf(node_id: number, msg: bigint): bigint {
46825 if(!isWasmInitialized) {
46826 throw new Error("initializeWasm() must be awaited first!");
46828 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_init_rbf(node_id, msg);
46829 return nativeResponseValue;
46831 // struct LDKMessageSendEvent MessageSendEvent_send_tx_ack_rbf(struct LDKPublicKey node_id, struct LDKTxAckRbf msg);
46833 export function MessageSendEvent_send_tx_ack_rbf(node_id: number, msg: bigint): bigint {
46834 if(!isWasmInitialized) {
46835 throw new Error("initializeWasm() must be awaited first!");
46837 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_ack_rbf(node_id, msg);
46838 return nativeResponseValue;
46840 // struct LDKMessageSendEvent MessageSendEvent_send_tx_abort(struct LDKPublicKey node_id, struct LDKTxAddInput msg);
46842 export function MessageSendEvent_send_tx_abort(node_id: number, msg: bigint): bigint {
46843 if(!isWasmInitialized) {
46844 throw new Error("initializeWasm() must be awaited first!");
46846 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_abort(node_id, msg);
46847 return nativeResponseValue;
46849 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
46851 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
46852 if(!isWasmInitialized) {
46853 throw new Error("initializeWasm() must be awaited first!");
46855 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
46856 return nativeResponseValue;
46858 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
46860 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
46861 if(!isWasmInitialized) {
46862 throw new Error("initializeWasm() must be awaited first!");
46864 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
46865 return nativeResponseValue;
46867 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
46869 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
46870 if(!isWasmInitialized) {
46871 throw new Error("initializeWasm() must be awaited first!");
46873 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
46874 return nativeResponseValue;
46876 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
46878 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
46879 if(!isWasmInitialized) {
46880 throw new Error("initializeWasm() must be awaited first!");
46882 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
46883 return nativeResponseValue;
46885 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
46887 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
46888 if(!isWasmInitialized) {
46889 throw new Error("initializeWasm() must be awaited first!");
46891 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
46892 return nativeResponseValue;
46894 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
46896 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
46897 if(!isWasmInitialized) {
46898 throw new Error("initializeWasm() must be awaited first!");
46900 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
46901 return nativeResponseValue;
46903 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
46905 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
46906 if(!isWasmInitialized) {
46907 throw new Error("initializeWasm() must be awaited first!");
46909 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
46910 return nativeResponseValue;
46912 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
46914 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
46915 if(!isWasmInitialized) {
46916 throw new Error("initializeWasm() must be awaited first!");
46918 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
46919 return nativeResponseValue;
46921 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
46923 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
46924 if(!isWasmInitialized) {
46925 throw new Error("initializeWasm() must be awaited first!");
46927 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
46928 return nativeResponseValue;
46930 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
46932 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
46933 if(!isWasmInitialized) {
46934 throw new Error("initializeWasm() must be awaited first!");
46936 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
46937 return nativeResponseValue;
46939 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
46941 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
46942 if(!isWasmInitialized) {
46943 throw new Error("initializeWasm() must be awaited first!");
46945 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
46946 return nativeResponseValue;
46948 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
46950 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
46951 if(!isWasmInitialized) {
46952 throw new Error("initializeWasm() must be awaited first!");
46954 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
46955 return nativeResponseValue;
46957 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
46959 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
46960 if(!isWasmInitialized) {
46961 throw new Error("initializeWasm() must be awaited first!");
46963 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
46964 return nativeResponseValue;
46966 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
46968 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
46969 if(!isWasmInitialized) {
46970 throw new Error("initializeWasm() must be awaited first!");
46972 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
46973 return nativeResponseValue;
46975 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
46977 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
46978 if(!isWasmInitialized) {
46979 throw new Error("initializeWasm() must be awaited first!");
46981 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
46982 return nativeResponseValue;
46984 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
46986 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
46987 if(!isWasmInitialized) {
46988 throw new Error("initializeWasm() must be awaited first!");
46990 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
46991 return nativeResponseValue;
46993 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
46995 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
46996 if(!isWasmInitialized) {
46997 throw new Error("initializeWasm() must be awaited first!");
46999 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
47000 return nativeResponseValue;
47002 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
47004 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
47005 if(!isWasmInitialized) {
47006 throw new Error("initializeWasm() must be awaited first!");
47008 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
47009 // debug statements here
47011 // void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
47013 export function OnionMessageProvider_free(this_ptr: bigint): void {
47014 if(!isWasmInitialized) {
47015 throw new Error("initializeWasm() must be awaited first!");
47017 const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
47018 // debug statements here
47020 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
47022 export function EventsProvider_free(this_ptr: bigint): void {
47023 if(!isWasmInitialized) {
47024 throw new Error("initializeWasm() must be awaited first!");
47026 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
47027 // debug statements here
47029 // void EventHandler_free(struct LDKEventHandler this_ptr);
47031 export function EventHandler_free(this_ptr: bigint): void {
47032 if(!isWasmInitialized) {
47033 throw new Error("initializeWasm() must be awaited first!");
47035 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
47036 // debug statements here
47038 // void ChannelDerivationParameters_free(struct LDKChannelDerivationParameters this_obj);
47040 export function ChannelDerivationParameters_free(this_obj: bigint): void {
47041 if(!isWasmInitialized) {
47042 throw new Error("initializeWasm() must be awaited first!");
47044 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_free(this_obj);
47045 // debug statements here
47047 // uint64_t ChannelDerivationParameters_get_value_satoshis(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
47049 export function ChannelDerivationParameters_get_value_satoshis(this_ptr: bigint): bigint {
47050 if(!isWasmInitialized) {
47051 throw new Error("initializeWasm() must be awaited first!");
47053 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_value_satoshis(this_ptr);
47054 return nativeResponseValue;
47056 // void ChannelDerivationParameters_set_value_satoshis(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, uint64_t val);
47058 export function ChannelDerivationParameters_set_value_satoshis(this_ptr: bigint, val: bigint): void {
47059 if(!isWasmInitialized) {
47060 throw new Error("initializeWasm() must be awaited first!");
47062 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_value_satoshis(this_ptr, val);
47063 // debug statements here
47065 // const uint8_t (*ChannelDerivationParameters_get_keys_id(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr))[32];
47067 export function ChannelDerivationParameters_get_keys_id(this_ptr: bigint): number {
47068 if(!isWasmInitialized) {
47069 throw new Error("initializeWasm() must be awaited first!");
47071 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_keys_id(this_ptr);
47072 return nativeResponseValue;
47074 // void ChannelDerivationParameters_set_keys_id(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
47076 export function ChannelDerivationParameters_set_keys_id(this_ptr: bigint, val: number): void {
47077 if(!isWasmInitialized) {
47078 throw new Error("initializeWasm() must be awaited first!");
47080 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_keys_id(this_ptr, val);
47081 // debug statements here
47083 // struct LDKChannelTransactionParameters ChannelDerivationParameters_get_transaction_parameters(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
47085 export function ChannelDerivationParameters_get_transaction_parameters(this_ptr: bigint): bigint {
47086 if(!isWasmInitialized) {
47087 throw new Error("initializeWasm() must be awaited first!");
47089 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_transaction_parameters(this_ptr);
47090 return nativeResponseValue;
47092 // void ChannelDerivationParameters_set_transaction_parameters(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
47094 export function ChannelDerivationParameters_set_transaction_parameters(this_ptr: bigint, val: bigint): void {
47095 if(!isWasmInitialized) {
47096 throw new Error("initializeWasm() must be awaited first!");
47098 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_transaction_parameters(this_ptr, val);
47099 // debug statements here
47101 // MUST_USE_RES struct LDKChannelDerivationParameters ChannelDerivationParameters_new(uint64_t value_satoshis_arg, struct LDKThirtyTwoBytes keys_id_arg, struct LDKChannelTransactionParameters transaction_parameters_arg);
47103 export function ChannelDerivationParameters_new(value_satoshis_arg: bigint, keys_id_arg: number, transaction_parameters_arg: bigint): bigint {
47104 if(!isWasmInitialized) {
47105 throw new Error("initializeWasm() must be awaited first!");
47107 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg, transaction_parameters_arg);
47108 return nativeResponseValue;
47110 // uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg);
47112 export function ChannelDerivationParameters_clone_ptr(arg: bigint): bigint {
47113 if(!isWasmInitialized) {
47114 throw new Error("initializeWasm() must be awaited first!");
47116 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone_ptr(arg);
47117 return nativeResponseValue;
47119 // struct LDKChannelDerivationParameters ChannelDerivationParameters_clone(const struct LDKChannelDerivationParameters *NONNULL_PTR orig);
47121 export function ChannelDerivationParameters_clone(orig: bigint): bigint {
47122 if(!isWasmInitialized) {
47123 throw new Error("initializeWasm() must be awaited first!");
47125 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone(orig);
47126 return nativeResponseValue;
47128 // bool ChannelDerivationParameters_eq(const struct LDKChannelDerivationParameters *NONNULL_PTR a, const struct LDKChannelDerivationParameters *NONNULL_PTR b);
47130 export function ChannelDerivationParameters_eq(a: bigint, b: bigint): boolean {
47131 if(!isWasmInitialized) {
47132 throw new Error("initializeWasm() must be awaited first!");
47134 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_eq(a, b);
47135 return nativeResponseValue;
47137 // void AnchorDescriptor_free(struct LDKAnchorDescriptor this_obj);
47139 export function AnchorDescriptor_free(this_obj: bigint): void {
47140 if(!isWasmInitialized) {
47141 throw new Error("initializeWasm() must be awaited first!");
47143 const nativeResponseValue = wasm.TS_AnchorDescriptor_free(this_obj);
47144 // debug statements here
47146 // struct LDKChannelDerivationParameters AnchorDescriptor_get_channel_derivation_parameters(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
47148 export function AnchorDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
47149 if(!isWasmInitialized) {
47150 throw new Error("initializeWasm() must be awaited first!");
47152 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_channel_derivation_parameters(this_ptr);
47153 return nativeResponseValue;
47155 // void AnchorDescriptor_set_channel_derivation_parameters(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
47157 export function AnchorDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
47158 if(!isWasmInitialized) {
47159 throw new Error("initializeWasm() must be awaited first!");
47161 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_channel_derivation_parameters(this_ptr, val);
47162 // debug statements here
47164 // struct LDKOutPoint AnchorDescriptor_get_outpoint(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
47166 export function AnchorDescriptor_get_outpoint(this_ptr: bigint): bigint {
47167 if(!isWasmInitialized) {
47168 throw new Error("initializeWasm() must be awaited first!");
47170 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_outpoint(this_ptr);
47171 return nativeResponseValue;
47173 // void AnchorDescriptor_set_outpoint(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
47175 export function AnchorDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
47176 if(!isWasmInitialized) {
47177 throw new Error("initializeWasm() must be awaited first!");
47179 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_outpoint(this_ptr, val);
47180 // debug statements here
47182 // MUST_USE_RES struct LDKAnchorDescriptor AnchorDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKOutPoint outpoint_arg);
47184 export function AnchorDescriptor_new(channel_derivation_parameters_arg: bigint, outpoint_arg: bigint): bigint {
47185 if(!isWasmInitialized) {
47186 throw new Error("initializeWasm() must be awaited first!");
47188 const nativeResponseValue = wasm.TS_AnchorDescriptor_new(channel_derivation_parameters_arg, outpoint_arg);
47189 return nativeResponseValue;
47191 // uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg);
47193 export function AnchorDescriptor_clone_ptr(arg: bigint): bigint {
47194 if(!isWasmInitialized) {
47195 throw new Error("initializeWasm() must be awaited first!");
47197 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone_ptr(arg);
47198 return nativeResponseValue;
47200 // struct LDKAnchorDescriptor AnchorDescriptor_clone(const struct LDKAnchorDescriptor *NONNULL_PTR orig);
47202 export function AnchorDescriptor_clone(orig: bigint): bigint {
47203 if(!isWasmInitialized) {
47204 throw new Error("initializeWasm() must be awaited first!");
47206 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone(orig);
47207 return nativeResponseValue;
47209 // bool AnchorDescriptor_eq(const struct LDKAnchorDescriptor *NONNULL_PTR a, const struct LDKAnchorDescriptor *NONNULL_PTR b);
47211 export function AnchorDescriptor_eq(a: bigint, b: bigint): boolean {
47212 if(!isWasmInitialized) {
47213 throw new Error("initializeWasm() must be awaited first!");
47215 const nativeResponseValue = wasm.TS_AnchorDescriptor_eq(a, b);
47216 return nativeResponseValue;
47218 // MUST_USE_RES struct LDKTxOut AnchorDescriptor_previous_utxo(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
47220 export function AnchorDescriptor_previous_utxo(this_arg: bigint): bigint {
47221 if(!isWasmInitialized) {
47222 throw new Error("initializeWasm() must be awaited first!");
47224 const nativeResponseValue = wasm.TS_AnchorDescriptor_previous_utxo(this_arg);
47225 return nativeResponseValue;
47227 // MUST_USE_RES struct LDKTxIn AnchorDescriptor_unsigned_tx_input(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
47229 export function AnchorDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
47230 if(!isWasmInitialized) {
47231 throw new Error("initializeWasm() must be awaited first!");
47233 const nativeResponseValue = wasm.TS_AnchorDescriptor_unsigned_tx_input(this_arg);
47234 return nativeResponseValue;
47236 // MUST_USE_RES struct LDKCVec_u8Z AnchorDescriptor_witness_script(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
47238 export function AnchorDescriptor_witness_script(this_arg: bigint): number {
47239 if(!isWasmInitialized) {
47240 throw new Error("initializeWasm() must be awaited first!");
47242 const nativeResponseValue = wasm.TS_AnchorDescriptor_witness_script(this_arg);
47243 return nativeResponseValue;
47245 // MUST_USE_RES struct LDKWitness AnchorDescriptor_tx_input_witness(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, struct LDKSignature signature);
47247 export function AnchorDescriptor_tx_input_witness(this_arg: bigint, signature: number): number {
47248 if(!isWasmInitialized) {
47249 throw new Error("initializeWasm() must be awaited first!");
47251 const nativeResponseValue = wasm.TS_AnchorDescriptor_tx_input_witness(this_arg, signature);
47252 return nativeResponseValue;
47254 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner AnchorDescriptor_derive_channel_signer(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
47256 export function AnchorDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
47257 if(!isWasmInitialized) {
47258 throw new Error("initializeWasm() must be awaited first!");
47260 const nativeResponseValue = wasm.TS_AnchorDescriptor_derive_channel_signer(this_arg, signer_provider);
47261 return nativeResponseValue;
47263 // void HTLCDescriptor_free(struct LDKHTLCDescriptor this_obj);
47265 export function HTLCDescriptor_free(this_obj: bigint): void {
47266 if(!isWasmInitialized) {
47267 throw new Error("initializeWasm() must be awaited first!");
47269 const nativeResponseValue = wasm.TS_HTLCDescriptor_free(this_obj);
47270 // debug statements here
47272 // struct LDKChannelDerivationParameters HTLCDescriptor_get_channel_derivation_parameters(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
47274 export function HTLCDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
47275 if(!isWasmInitialized) {
47276 throw new Error("initializeWasm() must be awaited first!");
47278 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_channel_derivation_parameters(this_ptr);
47279 return nativeResponseValue;
47281 // void HTLCDescriptor_set_channel_derivation_parameters(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
47283 export function HTLCDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
47284 if(!isWasmInitialized) {
47285 throw new Error("initializeWasm() must be awaited first!");
47287 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_channel_derivation_parameters(this_ptr, val);
47288 // debug statements here
47290 // uint64_t HTLCDescriptor_get_per_commitment_number(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
47292 export function HTLCDescriptor_get_per_commitment_number(this_ptr: bigint): bigint {
47293 if(!isWasmInitialized) {
47294 throw new Error("initializeWasm() must be awaited first!");
47296 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_number(this_ptr);
47297 return nativeResponseValue;
47299 // void HTLCDescriptor_set_per_commitment_number(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint64_t val);
47301 export function HTLCDescriptor_set_per_commitment_number(this_ptr: bigint, val: bigint): void {
47302 if(!isWasmInitialized) {
47303 throw new Error("initializeWasm() must be awaited first!");
47305 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_number(this_ptr, val);
47306 // debug statements here
47308 // struct LDKPublicKey HTLCDescriptor_get_per_commitment_point(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
47310 export function HTLCDescriptor_get_per_commitment_point(this_ptr: bigint): number {
47311 if(!isWasmInitialized) {
47312 throw new Error("initializeWasm() must be awaited first!");
47314 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_point(this_ptr);
47315 return nativeResponseValue;
47317 // void HTLCDescriptor_set_per_commitment_point(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
47319 export function HTLCDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
47320 if(!isWasmInitialized) {
47321 throw new Error("initializeWasm() must be awaited first!");
47323 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_point(this_ptr, val);
47324 // debug statements here
47326 // struct LDKHTLCOutputInCommitment HTLCDescriptor_get_htlc(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
47328 export function HTLCDescriptor_get_htlc(this_ptr: bigint): bigint {
47329 if(!isWasmInitialized) {
47330 throw new Error("initializeWasm() must be awaited first!");
47332 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_htlc(this_ptr);
47333 return nativeResponseValue;
47335 // void HTLCDescriptor_set_htlc(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKHTLCOutputInCommitment val);
47337 export function HTLCDescriptor_set_htlc(this_ptr: bigint, val: bigint): void {
47338 if(!isWasmInitialized) {
47339 throw new Error("initializeWasm() must be awaited first!");
47341 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_htlc(this_ptr, val);
47342 // debug statements here
47344 // struct LDKCOption_PaymentPreimageZ HTLCDescriptor_get_preimage(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
47346 export function HTLCDescriptor_get_preimage(this_ptr: bigint): bigint {
47347 if(!isWasmInitialized) {
47348 throw new Error("initializeWasm() must be awaited first!");
47350 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_preimage(this_ptr);
47351 return nativeResponseValue;
47353 // void HTLCDescriptor_set_preimage(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKCOption_PaymentPreimageZ val);
47355 export function HTLCDescriptor_set_preimage(this_ptr: bigint, val: bigint): void {
47356 if(!isWasmInitialized) {
47357 throw new Error("initializeWasm() must be awaited first!");
47359 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_preimage(this_ptr, val);
47360 // debug statements here
47362 // struct LDKSignature HTLCDescriptor_get_counterparty_sig(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
47364 export function HTLCDescriptor_get_counterparty_sig(this_ptr: bigint): number {
47365 if(!isWasmInitialized) {
47366 throw new Error("initializeWasm() must be awaited first!");
47368 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_counterparty_sig(this_ptr);
47369 return nativeResponseValue;
47371 // void HTLCDescriptor_set_counterparty_sig(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKSignature val);
47373 export function HTLCDescriptor_set_counterparty_sig(this_ptr: bigint, val: number): void {
47374 if(!isWasmInitialized) {
47375 throw new Error("initializeWasm() must be awaited first!");
47377 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_counterparty_sig(this_ptr, val);
47378 // debug statements here
47380 // uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg);
47382 export function HTLCDescriptor_clone_ptr(arg: bigint): bigint {
47383 if(!isWasmInitialized) {
47384 throw new Error("initializeWasm() must be awaited first!");
47386 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone_ptr(arg);
47387 return nativeResponseValue;
47389 // struct LDKHTLCDescriptor HTLCDescriptor_clone(const struct LDKHTLCDescriptor *NONNULL_PTR orig);
47391 export function HTLCDescriptor_clone(orig: bigint): bigint {
47392 if(!isWasmInitialized) {
47393 throw new Error("initializeWasm() must be awaited first!");
47395 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone(orig);
47396 return nativeResponseValue;
47398 // bool HTLCDescriptor_eq(const struct LDKHTLCDescriptor *NONNULL_PTR a, const struct LDKHTLCDescriptor *NONNULL_PTR b);
47400 export function HTLCDescriptor_eq(a: bigint, b: bigint): boolean {
47401 if(!isWasmInitialized) {
47402 throw new Error("initializeWasm() must be awaited first!");
47404 const nativeResponseValue = wasm.TS_HTLCDescriptor_eq(a, b);
47405 return nativeResponseValue;
47407 // MUST_USE_RES struct LDKOutPoint HTLCDescriptor_outpoint(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
47409 export function HTLCDescriptor_outpoint(this_arg: bigint): bigint {
47410 if(!isWasmInitialized) {
47411 throw new Error("initializeWasm() must be awaited first!");
47413 const nativeResponseValue = wasm.TS_HTLCDescriptor_outpoint(this_arg);
47414 return nativeResponseValue;
47416 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_previous_utxo(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
47418 export function HTLCDescriptor_previous_utxo(this_arg: bigint): bigint {
47419 if(!isWasmInitialized) {
47420 throw new Error("initializeWasm() must be awaited first!");
47422 const nativeResponseValue = wasm.TS_HTLCDescriptor_previous_utxo(this_arg);
47423 return nativeResponseValue;
47425 // MUST_USE_RES struct LDKTxIn HTLCDescriptor_unsigned_tx_input(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
47427 export function HTLCDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
47428 if(!isWasmInitialized) {
47429 throw new Error("initializeWasm() must be awaited first!");
47431 const nativeResponseValue = wasm.TS_HTLCDescriptor_unsigned_tx_input(this_arg);
47432 return nativeResponseValue;
47434 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_tx_output(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
47436 export function HTLCDescriptor_tx_output(this_arg: bigint): bigint {
47437 if(!isWasmInitialized) {
47438 throw new Error("initializeWasm() must be awaited first!");
47440 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_output(this_arg);
47441 return nativeResponseValue;
47443 // MUST_USE_RES struct LDKCVec_u8Z HTLCDescriptor_witness_script(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
47445 export function HTLCDescriptor_witness_script(this_arg: bigint): number {
47446 if(!isWasmInitialized) {
47447 throw new Error("initializeWasm() must be awaited first!");
47449 const nativeResponseValue = wasm.TS_HTLCDescriptor_witness_script(this_arg);
47450 return nativeResponseValue;
47452 // MUST_USE_RES struct LDKWitness HTLCDescriptor_tx_input_witness(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, struct LDKSignature signature, struct LDKu8slice witness_script);
47454 export function HTLCDescriptor_tx_input_witness(this_arg: bigint, signature: number, witness_script: number): number {
47455 if(!isWasmInitialized) {
47456 throw new Error("initializeWasm() must be awaited first!");
47458 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_input_witness(this_arg, signature, witness_script);
47459 return nativeResponseValue;
47461 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner HTLCDescriptor_derive_channel_signer(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
47463 export function HTLCDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
47464 if(!isWasmInitialized) {
47465 throw new Error("initializeWasm() must be awaited first!");
47467 const nativeResponseValue = wasm.TS_HTLCDescriptor_derive_channel_signer(this_arg, signer_provider);
47468 return nativeResponseValue;
47470 // void BumpTransactionEvent_free(struct LDKBumpTransactionEvent this_ptr);
47472 export function BumpTransactionEvent_free(this_ptr: bigint): void {
47473 if(!isWasmInitialized) {
47474 throw new Error("initializeWasm() must be awaited first!");
47476 const nativeResponseValue = wasm.TS_BumpTransactionEvent_free(this_ptr);
47477 // debug statements here
47479 // uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg);
47481 export function BumpTransactionEvent_clone_ptr(arg: bigint): bigint {
47482 if(!isWasmInitialized) {
47483 throw new Error("initializeWasm() must be awaited first!");
47485 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone_ptr(arg);
47486 return nativeResponseValue;
47488 // struct LDKBumpTransactionEvent BumpTransactionEvent_clone(const struct LDKBumpTransactionEvent *NONNULL_PTR orig);
47490 export function BumpTransactionEvent_clone(orig: bigint): bigint {
47491 if(!isWasmInitialized) {
47492 throw new Error("initializeWasm() must be awaited first!");
47494 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone(orig);
47495 return nativeResponseValue;
47497 // struct LDKBumpTransactionEvent BumpTransactionEvent_channel_close(struct LDKThirtyTwoBytes claim_id, uint32_t package_target_feerate_sat_per_1000_weight, struct LDKTransaction commitment_tx, uint64_t commitment_tx_fee_satoshis, struct LDKAnchorDescriptor anchor_descriptor, struct LDKCVec_HTLCOutputInCommitmentZ pending_htlcs);
47499 export function BumpTransactionEvent_channel_close(claim_id: number, package_target_feerate_sat_per_1000_weight: number, commitment_tx: number, commitment_tx_fee_satoshis: bigint, anchor_descriptor: bigint, pending_htlcs: number): bigint {
47500 if(!isWasmInitialized) {
47501 throw new Error("initializeWasm() must be awaited first!");
47503 const nativeResponseValue = wasm.TS_BumpTransactionEvent_channel_close(claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx, commitment_tx_fee_satoshis, anchor_descriptor, pending_htlcs);
47504 return nativeResponseValue;
47506 // struct LDKBumpTransactionEvent BumpTransactionEvent_htlcresolution(struct LDKThirtyTwoBytes claim_id, uint32_t target_feerate_sat_per_1000_weight, struct LDKCVec_HTLCDescriptorZ htlc_descriptors, uint32_t tx_lock_time);
47508 export function BumpTransactionEvent_htlcresolution(claim_id: number, target_feerate_sat_per_1000_weight: number, htlc_descriptors: number, tx_lock_time: number): bigint {
47509 if(!isWasmInitialized) {
47510 throw new Error("initializeWasm() must be awaited first!");
47512 const nativeResponseValue = wasm.TS_BumpTransactionEvent_htlcresolution(claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time);
47513 return nativeResponseValue;
47515 // bool BumpTransactionEvent_eq(const struct LDKBumpTransactionEvent *NONNULL_PTR a, const struct LDKBumpTransactionEvent *NONNULL_PTR b);
47517 export function BumpTransactionEvent_eq(a: bigint, b: bigint): boolean {
47518 if(!isWasmInitialized) {
47519 throw new Error("initializeWasm() must be awaited first!");
47521 const nativeResponseValue = wasm.TS_BumpTransactionEvent_eq(a, b);
47522 return nativeResponseValue;
47524 // void Input_free(struct LDKInput this_obj);
47526 export function Input_free(this_obj: bigint): void {
47527 if(!isWasmInitialized) {
47528 throw new Error("initializeWasm() must be awaited first!");
47530 const nativeResponseValue = wasm.TS_Input_free(this_obj);
47531 // debug statements here
47533 // struct LDKOutPoint Input_get_outpoint(const struct LDKInput *NONNULL_PTR this_ptr);
47535 export function Input_get_outpoint(this_ptr: bigint): bigint {
47536 if(!isWasmInitialized) {
47537 throw new Error("initializeWasm() must be awaited first!");
47539 const nativeResponseValue = wasm.TS_Input_get_outpoint(this_ptr);
47540 return nativeResponseValue;
47542 // void Input_set_outpoint(struct LDKInput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
47544 export function Input_set_outpoint(this_ptr: bigint, val: bigint): void {
47545 if(!isWasmInitialized) {
47546 throw new Error("initializeWasm() must be awaited first!");
47548 const nativeResponseValue = wasm.TS_Input_set_outpoint(this_ptr, val);
47549 // debug statements here
47551 // struct LDKTxOut Input_get_previous_utxo(const struct LDKInput *NONNULL_PTR this_ptr);
47553 export function Input_get_previous_utxo(this_ptr: bigint): bigint {
47554 if(!isWasmInitialized) {
47555 throw new Error("initializeWasm() must be awaited first!");
47557 const nativeResponseValue = wasm.TS_Input_get_previous_utxo(this_ptr);
47558 return nativeResponseValue;
47560 // void Input_set_previous_utxo(struct LDKInput *NONNULL_PTR this_ptr, struct LDKTxOut val);
47562 export function Input_set_previous_utxo(this_ptr: bigint, val: bigint): void {
47563 if(!isWasmInitialized) {
47564 throw new Error("initializeWasm() must be awaited first!");
47566 const nativeResponseValue = wasm.TS_Input_set_previous_utxo(this_ptr, val);
47567 // debug statements here
47569 // uint64_t Input_get_satisfaction_weight(const struct LDKInput *NONNULL_PTR this_ptr);
47571 export function Input_get_satisfaction_weight(this_ptr: bigint): bigint {
47572 if(!isWasmInitialized) {
47573 throw new Error("initializeWasm() must be awaited first!");
47575 const nativeResponseValue = wasm.TS_Input_get_satisfaction_weight(this_ptr);
47576 return nativeResponseValue;
47578 // void Input_set_satisfaction_weight(struct LDKInput *NONNULL_PTR this_ptr, uint64_t val);
47580 export function Input_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
47581 if(!isWasmInitialized) {
47582 throw new Error("initializeWasm() must be awaited first!");
47584 const nativeResponseValue = wasm.TS_Input_set_satisfaction_weight(this_ptr, val);
47585 // debug statements here
47587 // MUST_USE_RES struct LDKInput Input_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut previous_utxo_arg, uint64_t satisfaction_weight_arg);
47589 export function Input_new(outpoint_arg: bigint, previous_utxo_arg: bigint, satisfaction_weight_arg: bigint): bigint {
47590 if(!isWasmInitialized) {
47591 throw new Error("initializeWasm() must be awaited first!");
47593 const nativeResponseValue = wasm.TS_Input_new(outpoint_arg, previous_utxo_arg, satisfaction_weight_arg);
47594 return nativeResponseValue;
47596 // uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg);
47598 export function Input_clone_ptr(arg: bigint): bigint {
47599 if(!isWasmInitialized) {
47600 throw new Error("initializeWasm() must be awaited first!");
47602 const nativeResponseValue = wasm.TS_Input_clone_ptr(arg);
47603 return nativeResponseValue;
47605 // struct LDKInput Input_clone(const struct LDKInput *NONNULL_PTR orig);
47607 export function Input_clone(orig: bigint): bigint {
47608 if(!isWasmInitialized) {
47609 throw new Error("initializeWasm() must be awaited first!");
47611 const nativeResponseValue = wasm.TS_Input_clone(orig);
47612 return nativeResponseValue;
47614 // uint64_t Input_hash(const struct LDKInput *NONNULL_PTR o);
47616 export function Input_hash(o: bigint): bigint {
47617 if(!isWasmInitialized) {
47618 throw new Error("initializeWasm() must be awaited first!");
47620 const nativeResponseValue = wasm.TS_Input_hash(o);
47621 return nativeResponseValue;
47623 // bool Input_eq(const struct LDKInput *NONNULL_PTR a, const struct LDKInput *NONNULL_PTR b);
47625 export function Input_eq(a: bigint, b: bigint): boolean {
47626 if(!isWasmInitialized) {
47627 throw new Error("initializeWasm() must be awaited first!");
47629 const nativeResponseValue = wasm.TS_Input_eq(a, b);
47630 return nativeResponseValue;
47632 // void Utxo_free(struct LDKUtxo this_obj);
47634 export function Utxo_free(this_obj: bigint): void {
47635 if(!isWasmInitialized) {
47636 throw new Error("initializeWasm() must be awaited first!");
47638 const nativeResponseValue = wasm.TS_Utxo_free(this_obj);
47639 // debug statements here
47641 // struct LDKOutPoint Utxo_get_outpoint(const struct LDKUtxo *NONNULL_PTR this_ptr);
47643 export function Utxo_get_outpoint(this_ptr: bigint): bigint {
47644 if(!isWasmInitialized) {
47645 throw new Error("initializeWasm() must be awaited first!");
47647 const nativeResponseValue = wasm.TS_Utxo_get_outpoint(this_ptr);
47648 return nativeResponseValue;
47650 // void Utxo_set_outpoint(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKOutPoint val);
47652 export function Utxo_set_outpoint(this_ptr: bigint, val: bigint): void {
47653 if(!isWasmInitialized) {
47654 throw new Error("initializeWasm() must be awaited first!");
47656 const nativeResponseValue = wasm.TS_Utxo_set_outpoint(this_ptr, val);
47657 // debug statements here
47659 // struct LDKTxOut Utxo_get_output(const struct LDKUtxo *NONNULL_PTR this_ptr);
47661 export function Utxo_get_output(this_ptr: bigint): bigint {
47662 if(!isWasmInitialized) {
47663 throw new Error("initializeWasm() must be awaited first!");
47665 const nativeResponseValue = wasm.TS_Utxo_get_output(this_ptr);
47666 return nativeResponseValue;
47668 // void Utxo_set_output(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKTxOut val);
47670 export function Utxo_set_output(this_ptr: bigint, val: bigint): void {
47671 if(!isWasmInitialized) {
47672 throw new Error("initializeWasm() must be awaited first!");
47674 const nativeResponseValue = wasm.TS_Utxo_set_output(this_ptr, val);
47675 // debug statements here
47677 // uint64_t Utxo_get_satisfaction_weight(const struct LDKUtxo *NONNULL_PTR this_ptr);
47679 export function Utxo_get_satisfaction_weight(this_ptr: bigint): bigint {
47680 if(!isWasmInitialized) {
47681 throw new Error("initializeWasm() must be awaited first!");
47683 const nativeResponseValue = wasm.TS_Utxo_get_satisfaction_weight(this_ptr);
47684 return nativeResponseValue;
47686 // void Utxo_set_satisfaction_weight(struct LDKUtxo *NONNULL_PTR this_ptr, uint64_t val);
47688 export function Utxo_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
47689 if(!isWasmInitialized) {
47690 throw new Error("initializeWasm() must be awaited first!");
47692 const nativeResponseValue = wasm.TS_Utxo_set_satisfaction_weight(this_ptr, val);
47693 // debug statements here
47695 // MUST_USE_RES struct LDKUtxo Utxo_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, uint64_t satisfaction_weight_arg);
47697 export function Utxo_new(outpoint_arg: bigint, output_arg: bigint, satisfaction_weight_arg: bigint): bigint {
47698 if(!isWasmInitialized) {
47699 throw new Error("initializeWasm() must be awaited first!");
47701 const nativeResponseValue = wasm.TS_Utxo_new(outpoint_arg, output_arg, satisfaction_weight_arg);
47702 return nativeResponseValue;
47704 // uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg);
47706 export function Utxo_clone_ptr(arg: bigint): bigint {
47707 if(!isWasmInitialized) {
47708 throw new Error("initializeWasm() must be awaited first!");
47710 const nativeResponseValue = wasm.TS_Utxo_clone_ptr(arg);
47711 return nativeResponseValue;
47713 // struct LDKUtxo Utxo_clone(const struct LDKUtxo *NONNULL_PTR orig);
47715 export function Utxo_clone(orig: bigint): bigint {
47716 if(!isWasmInitialized) {
47717 throw new Error("initializeWasm() must be awaited first!");
47719 const nativeResponseValue = wasm.TS_Utxo_clone(orig);
47720 return nativeResponseValue;
47722 // uint64_t Utxo_hash(const struct LDKUtxo *NONNULL_PTR o);
47724 export function Utxo_hash(o: bigint): bigint {
47725 if(!isWasmInitialized) {
47726 throw new Error("initializeWasm() must be awaited first!");
47728 const nativeResponseValue = wasm.TS_Utxo_hash(o);
47729 return nativeResponseValue;
47731 // bool Utxo_eq(const struct LDKUtxo *NONNULL_PTR a, const struct LDKUtxo *NONNULL_PTR b);
47733 export function Utxo_eq(a: bigint, b: bigint): boolean {
47734 if(!isWasmInitialized) {
47735 throw new Error("initializeWasm() must be awaited first!");
47737 const nativeResponseValue = wasm.TS_Utxo_eq(a, b);
47738 return nativeResponseValue;
47740 // MUST_USE_RES struct LDKUtxo Utxo_new_p2pkh(struct LDKOutPoint outpoint, uint64_t value, const uint8_t (*pubkey_hash)[20]);
47742 export function Utxo_new_p2pkh(outpoint: bigint, value: bigint, pubkey_hash: number): bigint {
47743 if(!isWasmInitialized) {
47744 throw new Error("initializeWasm() must be awaited first!");
47746 const nativeResponseValue = wasm.TS_Utxo_new_p2pkh(outpoint, value, pubkey_hash);
47747 return nativeResponseValue;
47749 // void CoinSelection_free(struct LDKCoinSelection this_obj);
47751 export function CoinSelection_free(this_obj: bigint): void {
47752 if(!isWasmInitialized) {
47753 throw new Error("initializeWasm() must be awaited first!");
47755 const nativeResponseValue = wasm.TS_CoinSelection_free(this_obj);
47756 // debug statements here
47758 // struct LDKCVec_UtxoZ CoinSelection_get_confirmed_utxos(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
47760 export function CoinSelection_get_confirmed_utxos(this_ptr: bigint): number {
47761 if(!isWasmInitialized) {
47762 throw new Error("initializeWasm() must be awaited first!");
47764 const nativeResponseValue = wasm.TS_CoinSelection_get_confirmed_utxos(this_ptr);
47765 return nativeResponseValue;
47767 // void CoinSelection_set_confirmed_utxos(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCVec_UtxoZ val);
47769 export function CoinSelection_set_confirmed_utxos(this_ptr: bigint, val: number): void {
47770 if(!isWasmInitialized) {
47771 throw new Error("initializeWasm() must be awaited first!");
47773 const nativeResponseValue = wasm.TS_CoinSelection_set_confirmed_utxos(this_ptr, val);
47774 // debug statements here
47776 // struct LDKCOption_TxOutZ CoinSelection_get_change_output(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
47778 export function CoinSelection_get_change_output(this_ptr: bigint): bigint {
47779 if(!isWasmInitialized) {
47780 throw new Error("initializeWasm() must be awaited first!");
47782 const nativeResponseValue = wasm.TS_CoinSelection_get_change_output(this_ptr);
47783 return nativeResponseValue;
47785 // void CoinSelection_set_change_output(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCOption_TxOutZ val);
47787 export function CoinSelection_set_change_output(this_ptr: bigint, val: bigint): void {
47788 if(!isWasmInitialized) {
47789 throw new Error("initializeWasm() must be awaited first!");
47791 const nativeResponseValue = wasm.TS_CoinSelection_set_change_output(this_ptr, val);
47792 // debug statements here
47794 // MUST_USE_RES struct LDKCoinSelection CoinSelection_new(struct LDKCVec_UtxoZ confirmed_utxos_arg, struct LDKCOption_TxOutZ change_output_arg);
47796 export function CoinSelection_new(confirmed_utxos_arg: number, change_output_arg: bigint): bigint {
47797 if(!isWasmInitialized) {
47798 throw new Error("initializeWasm() must be awaited first!");
47800 const nativeResponseValue = wasm.TS_CoinSelection_new(confirmed_utxos_arg, change_output_arg);
47801 return nativeResponseValue;
47803 // uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg);
47805 export function CoinSelection_clone_ptr(arg: bigint): bigint {
47806 if(!isWasmInitialized) {
47807 throw new Error("initializeWasm() must be awaited first!");
47809 const nativeResponseValue = wasm.TS_CoinSelection_clone_ptr(arg);
47810 return nativeResponseValue;
47812 // struct LDKCoinSelection CoinSelection_clone(const struct LDKCoinSelection *NONNULL_PTR orig);
47814 export function CoinSelection_clone(orig: bigint): bigint {
47815 if(!isWasmInitialized) {
47816 throw new Error("initializeWasm() must be awaited first!");
47818 const nativeResponseValue = wasm.TS_CoinSelection_clone(orig);
47819 return nativeResponseValue;
47821 // void CoinSelectionSource_free(struct LDKCoinSelectionSource this_ptr);
47823 export function CoinSelectionSource_free(this_ptr: bigint): void {
47824 if(!isWasmInitialized) {
47825 throw new Error("initializeWasm() must be awaited first!");
47827 const nativeResponseValue = wasm.TS_CoinSelectionSource_free(this_ptr);
47828 // debug statements here
47830 // void WalletSource_free(struct LDKWalletSource this_ptr);
47832 export function WalletSource_free(this_ptr: bigint): void {
47833 if(!isWasmInitialized) {
47834 throw new Error("initializeWasm() must be awaited first!");
47836 const nativeResponseValue = wasm.TS_WalletSource_free(this_ptr);
47837 // debug statements here
47839 // void Wallet_free(struct LDKWallet this_obj);
47841 export function Wallet_free(this_obj: bigint): void {
47842 if(!isWasmInitialized) {
47843 throw new Error("initializeWasm() must be awaited first!");
47845 const nativeResponseValue = wasm.TS_Wallet_free(this_obj);
47846 // debug statements here
47848 // MUST_USE_RES struct LDKWallet Wallet_new(struct LDKWalletSource source, struct LDKLogger logger);
47850 export function Wallet_new(source: bigint, logger: bigint): bigint {
47851 if(!isWasmInitialized) {
47852 throw new Error("initializeWasm() must be awaited first!");
47854 const nativeResponseValue = wasm.TS_Wallet_new(source, logger);
47855 return nativeResponseValue;
47857 // struct LDKCoinSelectionSource Wallet_as_CoinSelectionSource(const struct LDKWallet *NONNULL_PTR this_arg);
47859 export function Wallet_as_CoinSelectionSource(this_arg: bigint): bigint {
47860 if(!isWasmInitialized) {
47861 throw new Error("initializeWasm() must be awaited first!");
47863 const nativeResponseValue = wasm.TS_Wallet_as_CoinSelectionSource(this_arg);
47864 return nativeResponseValue;
47866 // void BumpTransactionEventHandler_free(struct LDKBumpTransactionEventHandler this_obj);
47868 export function BumpTransactionEventHandler_free(this_obj: bigint): void {
47869 if(!isWasmInitialized) {
47870 throw new Error("initializeWasm() must be awaited first!");
47872 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_free(this_obj);
47873 // debug statements here
47875 // MUST_USE_RES struct LDKBumpTransactionEventHandler BumpTransactionEventHandler_new(struct LDKBroadcasterInterface broadcaster, struct LDKCoinSelectionSource utxo_source, struct LDKSignerProvider signer_provider, struct LDKLogger logger);
47877 export function BumpTransactionEventHandler_new(broadcaster: bigint, utxo_source: bigint, signer_provider: bigint, logger: bigint): bigint {
47878 if(!isWasmInitialized) {
47879 throw new Error("initializeWasm() must be awaited first!");
47881 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_new(broadcaster, utxo_source, signer_provider, logger);
47882 return nativeResponseValue;
47884 // void BumpTransactionEventHandler_handle_event(const struct LDKBumpTransactionEventHandler *NONNULL_PTR this_arg, const struct LDKBumpTransactionEvent *NONNULL_PTR event);
47886 export function BumpTransactionEventHandler_handle_event(this_arg: bigint, event: bigint): void {
47887 if(!isWasmInitialized) {
47888 throw new Error("initializeWasm() must be awaited first!");
47890 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_handle_event(this_arg, event);
47891 // debug statements here
47893 // void GossipSync_free(struct LDKGossipSync this_ptr);
47895 export function GossipSync_free(this_ptr: bigint): void {
47896 if(!isWasmInitialized) {
47897 throw new Error("initializeWasm() must be awaited first!");
47899 const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
47900 // debug statements here
47902 // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
47904 export function GossipSync_p2_p(a: bigint): bigint {
47905 if(!isWasmInitialized) {
47906 throw new Error("initializeWasm() must be awaited first!");
47908 const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
47909 return nativeResponseValue;
47911 // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
47913 export function GossipSync_rapid(a: bigint): bigint {
47914 if(!isWasmInitialized) {
47915 throw new Error("initializeWasm() must be awaited first!");
47917 const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
47918 return nativeResponseValue;
47920 // struct LDKGossipSync GossipSync_none(void);
47922 export function GossipSync_none(): bigint {
47923 if(!isWasmInitialized) {
47924 throw new Error("initializeWasm() must be awaited first!");
47926 const nativeResponseValue = wasm.TS_GossipSync_none();
47927 return nativeResponseValue;
47929 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
47931 export function RapidGossipSync_free(this_obj: bigint): void {
47932 if(!isWasmInitialized) {
47933 throw new Error("initializeWasm() must be awaited first!");
47935 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
47936 // debug statements here
47938 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
47940 export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
47941 if(!isWasmInitialized) {
47942 throw new Error("initializeWasm() must be awaited first!");
47944 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
47945 return nativeResponseValue;
47947 // 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);
47949 export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
47950 if(!isWasmInitialized) {
47951 throw new Error("initializeWasm() must be awaited first!");
47953 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
47954 return nativeResponseValue;
47956 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
47958 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
47959 if(!isWasmInitialized) {
47960 throw new Error("initializeWasm() must be awaited first!");
47962 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
47963 return nativeResponseValue;
47965 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
47967 export function GraphSyncError_free(this_ptr: bigint): void {
47968 if(!isWasmInitialized) {
47969 throw new Error("initializeWasm() must be awaited first!");
47971 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
47972 // debug statements here
47974 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
47976 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
47977 if(!isWasmInitialized) {
47978 throw new Error("initializeWasm() must be awaited first!");
47980 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
47981 return nativeResponseValue;
47983 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
47985 export function GraphSyncError_clone(orig: bigint): bigint {
47986 if(!isWasmInitialized) {
47987 throw new Error("initializeWasm() must be awaited first!");
47989 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
47990 return nativeResponseValue;
47992 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
47994 export function GraphSyncError_decode_error(a: bigint): bigint {
47995 if(!isWasmInitialized) {
47996 throw new Error("initializeWasm() must be awaited first!");
47998 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
47999 return nativeResponseValue;
48001 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
48003 export function GraphSyncError_lightning_error(a: bigint): bigint {
48004 if(!isWasmInitialized) {
48005 throw new Error("initializeWasm() must be awaited first!");
48007 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
48008 return nativeResponseValue;
48010 // void Bolt11ParseError_free(struct LDKBolt11ParseError this_ptr);
48012 export function Bolt11ParseError_free(this_ptr: bigint): void {
48013 if(!isWasmInitialized) {
48014 throw new Error("initializeWasm() must be awaited first!");
48016 const nativeResponseValue = wasm.TS_Bolt11ParseError_free(this_ptr);
48017 // debug statements here
48019 // uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg);
48021 export function Bolt11ParseError_clone_ptr(arg: bigint): bigint {
48022 if(!isWasmInitialized) {
48023 throw new Error("initializeWasm() must be awaited first!");
48025 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone_ptr(arg);
48026 return nativeResponseValue;
48028 // struct LDKBolt11ParseError Bolt11ParseError_clone(const struct LDKBolt11ParseError *NONNULL_PTR orig);
48030 export function Bolt11ParseError_clone(orig: bigint): bigint {
48031 if(!isWasmInitialized) {
48032 throw new Error("initializeWasm() must be awaited first!");
48034 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone(orig);
48035 return nativeResponseValue;
48037 // struct LDKBolt11ParseError Bolt11ParseError_bech32_error(struct LDKBech32Error a);
48039 export function Bolt11ParseError_bech32_error(a: bigint): bigint {
48040 if(!isWasmInitialized) {
48041 throw new Error("initializeWasm() must be awaited first!");
48043 const nativeResponseValue = wasm.TS_Bolt11ParseError_bech32_error(a);
48044 return nativeResponseValue;
48046 // struct LDKBolt11ParseError Bolt11ParseError_parse_amount_error(struct LDKError a);
48048 export function Bolt11ParseError_parse_amount_error(a: number): bigint {
48049 if(!isWasmInitialized) {
48050 throw new Error("initializeWasm() must be awaited first!");
48052 const nativeResponseValue = wasm.TS_Bolt11ParseError_parse_amount_error(a);
48053 return nativeResponseValue;
48055 // struct LDKBolt11ParseError Bolt11ParseError_malformed_signature(enum LDKSecp256k1Error a);
48057 export function Bolt11ParseError_malformed_signature(a: Secp256k1Error): bigint {
48058 if(!isWasmInitialized) {
48059 throw new Error("initializeWasm() must be awaited first!");
48061 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_signature(a);
48062 return nativeResponseValue;
48064 // struct LDKBolt11ParseError Bolt11ParseError_bad_prefix(void);
48066 export function Bolt11ParseError_bad_prefix(): bigint {
48067 if(!isWasmInitialized) {
48068 throw new Error("initializeWasm() must be awaited first!");
48070 const nativeResponseValue = wasm.TS_Bolt11ParseError_bad_prefix();
48071 return nativeResponseValue;
48073 // struct LDKBolt11ParseError Bolt11ParseError_unknown_currency(void);
48075 export function Bolt11ParseError_unknown_currency(): bigint {
48076 if(!isWasmInitialized) {
48077 throw new Error("initializeWasm() must be awaited first!");
48079 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_currency();
48080 return nativeResponseValue;
48082 // struct LDKBolt11ParseError Bolt11ParseError_unknown_si_prefix(void);
48084 export function Bolt11ParseError_unknown_si_prefix(): bigint {
48085 if(!isWasmInitialized) {
48086 throw new Error("initializeWasm() must be awaited first!");
48088 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_si_prefix();
48089 return nativeResponseValue;
48091 // struct LDKBolt11ParseError Bolt11ParseError_malformed_hrp(void);
48093 export function Bolt11ParseError_malformed_hrp(): bigint {
48094 if(!isWasmInitialized) {
48095 throw new Error("initializeWasm() must be awaited first!");
48097 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_hrp();
48098 return nativeResponseValue;
48100 // struct LDKBolt11ParseError Bolt11ParseError_too_short_data_part(void);
48102 export function Bolt11ParseError_too_short_data_part(): bigint {
48103 if(!isWasmInitialized) {
48104 throw new Error("initializeWasm() must be awaited first!");
48106 const nativeResponseValue = wasm.TS_Bolt11ParseError_too_short_data_part();
48107 return nativeResponseValue;
48109 // struct LDKBolt11ParseError Bolt11ParseError_unexpected_end_of_tagged_fields(void);
48111 export function Bolt11ParseError_unexpected_end_of_tagged_fields(): bigint {
48112 if(!isWasmInitialized) {
48113 throw new Error("initializeWasm() must be awaited first!");
48115 const nativeResponseValue = wasm.TS_Bolt11ParseError_unexpected_end_of_tagged_fields();
48116 return nativeResponseValue;
48118 // struct LDKBolt11ParseError Bolt11ParseError_description_decode_error(struct LDKError a);
48120 export function Bolt11ParseError_description_decode_error(a: number): bigint {
48121 if(!isWasmInitialized) {
48122 throw new Error("initializeWasm() must be awaited first!");
48124 const nativeResponseValue = wasm.TS_Bolt11ParseError_description_decode_error(a);
48125 return nativeResponseValue;
48127 // struct LDKBolt11ParseError Bolt11ParseError_padding_error(void);
48129 export function Bolt11ParseError_padding_error(): bigint {
48130 if(!isWasmInitialized) {
48131 throw new Error("initializeWasm() must be awaited first!");
48133 const nativeResponseValue = wasm.TS_Bolt11ParseError_padding_error();
48134 return nativeResponseValue;
48136 // struct LDKBolt11ParseError Bolt11ParseError_integer_overflow_error(void);
48138 export function Bolt11ParseError_integer_overflow_error(): bigint {
48139 if(!isWasmInitialized) {
48140 throw new Error("initializeWasm() must be awaited first!");
48142 const nativeResponseValue = wasm.TS_Bolt11ParseError_integer_overflow_error();
48143 return nativeResponseValue;
48145 // struct LDKBolt11ParseError Bolt11ParseError_invalid_seg_wit_program_length(void);
48147 export function Bolt11ParseError_invalid_seg_wit_program_length(): bigint {
48148 if(!isWasmInitialized) {
48149 throw new Error("initializeWasm() must be awaited first!");
48151 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_seg_wit_program_length();
48152 return nativeResponseValue;
48154 // struct LDKBolt11ParseError Bolt11ParseError_invalid_pub_key_hash_length(void);
48156 export function Bolt11ParseError_invalid_pub_key_hash_length(): bigint {
48157 if(!isWasmInitialized) {
48158 throw new Error("initializeWasm() must be awaited first!");
48160 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_pub_key_hash_length();
48161 return nativeResponseValue;
48163 // struct LDKBolt11ParseError Bolt11ParseError_invalid_script_hash_length(void);
48165 export function Bolt11ParseError_invalid_script_hash_length(): bigint {
48166 if(!isWasmInitialized) {
48167 throw new Error("initializeWasm() must be awaited first!");
48169 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_script_hash_length();
48170 return nativeResponseValue;
48172 // struct LDKBolt11ParseError Bolt11ParseError_invalid_recovery_id(void);
48174 export function Bolt11ParseError_invalid_recovery_id(): bigint {
48175 if(!isWasmInitialized) {
48176 throw new Error("initializeWasm() must be awaited first!");
48178 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_recovery_id();
48179 return nativeResponseValue;
48181 // struct LDKBolt11ParseError Bolt11ParseError_invalid_slice_length(struct LDKStr a);
48183 export function Bolt11ParseError_invalid_slice_length(a: number): bigint {
48184 if(!isWasmInitialized) {
48185 throw new Error("initializeWasm() must be awaited first!");
48187 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_slice_length(a);
48188 return nativeResponseValue;
48190 // struct LDKBolt11ParseError Bolt11ParseError_skip(void);
48192 export function Bolt11ParseError_skip(): bigint {
48193 if(!isWasmInitialized) {
48194 throw new Error("initializeWasm() must be awaited first!");
48196 const nativeResponseValue = wasm.TS_Bolt11ParseError_skip();
48197 return nativeResponseValue;
48199 // bool Bolt11ParseError_eq(const struct LDKBolt11ParseError *NONNULL_PTR a, const struct LDKBolt11ParseError *NONNULL_PTR b);
48201 export function Bolt11ParseError_eq(a: bigint, b: bigint): boolean {
48202 if(!isWasmInitialized) {
48203 throw new Error("initializeWasm() must be awaited first!");
48205 const nativeResponseValue = wasm.TS_Bolt11ParseError_eq(a, b);
48206 return nativeResponseValue;
48208 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
48210 export function ParseOrSemanticError_free(this_ptr: bigint): void {
48211 if(!isWasmInitialized) {
48212 throw new Error("initializeWasm() must be awaited first!");
48214 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
48215 // debug statements here
48217 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
48219 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
48220 if(!isWasmInitialized) {
48221 throw new Error("initializeWasm() must be awaited first!");
48223 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
48224 return nativeResponseValue;
48226 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
48228 export function ParseOrSemanticError_clone(orig: bigint): bigint {
48229 if(!isWasmInitialized) {
48230 throw new Error("initializeWasm() must be awaited first!");
48232 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
48233 return nativeResponseValue;
48235 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKBolt11ParseError a);
48237 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
48238 if(!isWasmInitialized) {
48239 throw new Error("initializeWasm() must be awaited first!");
48241 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
48242 return nativeResponseValue;
48244 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKBolt11SemanticError a);
48246 export function ParseOrSemanticError_semantic_error(a: Bolt11SemanticError): bigint {
48247 if(!isWasmInitialized) {
48248 throw new Error("initializeWasm() must be awaited first!");
48250 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
48251 return nativeResponseValue;
48253 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
48255 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
48256 if(!isWasmInitialized) {
48257 throw new Error("initializeWasm() must be awaited first!");
48259 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
48260 return nativeResponseValue;
48262 // void Bolt11Invoice_free(struct LDKBolt11Invoice this_obj);
48264 export function Bolt11Invoice_free(this_obj: bigint): void {
48265 if(!isWasmInitialized) {
48266 throw new Error("initializeWasm() must be awaited first!");
48268 const nativeResponseValue = wasm.TS_Bolt11Invoice_free(this_obj);
48269 // debug statements here
48271 // bool Bolt11Invoice_eq(const struct LDKBolt11Invoice *NONNULL_PTR a, const struct LDKBolt11Invoice *NONNULL_PTR b);
48273 export function Bolt11Invoice_eq(a: bigint, b: bigint): boolean {
48274 if(!isWasmInitialized) {
48275 throw new Error("initializeWasm() must be awaited first!");
48277 const nativeResponseValue = wasm.TS_Bolt11Invoice_eq(a, b);
48278 return nativeResponseValue;
48280 // uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg);
48282 export function Bolt11Invoice_clone_ptr(arg: bigint): bigint {
48283 if(!isWasmInitialized) {
48284 throw new Error("initializeWasm() must be awaited first!");
48286 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone_ptr(arg);
48287 return nativeResponseValue;
48289 // struct LDKBolt11Invoice Bolt11Invoice_clone(const struct LDKBolt11Invoice *NONNULL_PTR orig);
48291 export function Bolt11Invoice_clone(orig: bigint): bigint {
48292 if(!isWasmInitialized) {
48293 throw new Error("initializeWasm() must be awaited first!");
48295 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone(orig);
48296 return nativeResponseValue;
48298 // uint64_t Bolt11Invoice_hash(const struct LDKBolt11Invoice *NONNULL_PTR o);
48300 export function Bolt11Invoice_hash(o: bigint): bigint {
48301 if(!isWasmInitialized) {
48302 throw new Error("initializeWasm() must be awaited first!");
48304 const nativeResponseValue = wasm.TS_Bolt11Invoice_hash(o);
48305 return nativeResponseValue;
48307 // void SignedRawBolt11Invoice_free(struct LDKSignedRawBolt11Invoice this_obj);
48309 export function SignedRawBolt11Invoice_free(this_obj: bigint): void {
48310 if(!isWasmInitialized) {
48311 throw new Error("initializeWasm() must be awaited first!");
48313 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_free(this_obj);
48314 // debug statements here
48316 // bool SignedRawBolt11Invoice_eq(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR a, const struct LDKSignedRawBolt11Invoice *NONNULL_PTR b);
48318 export function SignedRawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
48319 if(!isWasmInitialized) {
48320 throw new Error("initializeWasm() must be awaited first!");
48322 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_eq(a, b);
48323 return nativeResponseValue;
48325 // uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg);
48327 export function SignedRawBolt11Invoice_clone_ptr(arg: bigint): bigint {
48328 if(!isWasmInitialized) {
48329 throw new Error("initializeWasm() must be awaited first!");
48331 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone_ptr(arg);
48332 return nativeResponseValue;
48334 // struct LDKSignedRawBolt11Invoice SignedRawBolt11Invoice_clone(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR orig);
48336 export function SignedRawBolt11Invoice_clone(orig: bigint): bigint {
48337 if(!isWasmInitialized) {
48338 throw new Error("initializeWasm() must be awaited first!");
48340 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone(orig);
48341 return nativeResponseValue;
48343 // uint64_t SignedRawBolt11Invoice_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
48345 export function SignedRawBolt11Invoice_hash(o: bigint): bigint {
48346 if(!isWasmInitialized) {
48347 throw new Error("initializeWasm() must be awaited first!");
48349 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_hash(o);
48350 return nativeResponseValue;
48352 // void RawBolt11Invoice_free(struct LDKRawBolt11Invoice this_obj);
48354 export function RawBolt11Invoice_free(this_obj: bigint): void {
48355 if(!isWasmInitialized) {
48356 throw new Error("initializeWasm() must be awaited first!");
48358 const nativeResponseValue = wasm.TS_RawBolt11Invoice_free(this_obj);
48359 // debug statements here
48361 // struct LDKRawDataPart RawBolt11Invoice_get_data(const struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr);
48363 export function RawBolt11Invoice_get_data(this_ptr: bigint): bigint {
48364 if(!isWasmInitialized) {
48365 throw new Error("initializeWasm() must be awaited first!");
48367 const nativeResponseValue = wasm.TS_RawBolt11Invoice_get_data(this_ptr);
48368 return nativeResponseValue;
48370 // void RawBolt11Invoice_set_data(struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
48372 export function RawBolt11Invoice_set_data(this_ptr: bigint, val: bigint): void {
48373 if(!isWasmInitialized) {
48374 throw new Error("initializeWasm() must be awaited first!");
48376 const nativeResponseValue = wasm.TS_RawBolt11Invoice_set_data(this_ptr, val);
48377 // debug statements here
48379 // bool RawBolt11Invoice_eq(const struct LDKRawBolt11Invoice *NONNULL_PTR a, const struct LDKRawBolt11Invoice *NONNULL_PTR b);
48381 export function RawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
48382 if(!isWasmInitialized) {
48383 throw new Error("initializeWasm() must be awaited first!");
48385 const nativeResponseValue = wasm.TS_RawBolt11Invoice_eq(a, b);
48386 return nativeResponseValue;
48388 // uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg);
48390 export function RawBolt11Invoice_clone_ptr(arg: bigint): bigint {
48391 if(!isWasmInitialized) {
48392 throw new Error("initializeWasm() must be awaited first!");
48394 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone_ptr(arg);
48395 return nativeResponseValue;
48397 // struct LDKRawBolt11Invoice RawBolt11Invoice_clone(const struct LDKRawBolt11Invoice *NONNULL_PTR orig);
48399 export function RawBolt11Invoice_clone(orig: bigint): bigint {
48400 if(!isWasmInitialized) {
48401 throw new Error("initializeWasm() must be awaited first!");
48403 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone(orig);
48404 return nativeResponseValue;
48406 // uint64_t RawBolt11Invoice_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR o);
48408 export function RawBolt11Invoice_hash(o: bigint): bigint {
48409 if(!isWasmInitialized) {
48410 throw new Error("initializeWasm() must be awaited first!");
48412 const nativeResponseValue = wasm.TS_RawBolt11Invoice_hash(o);
48413 return nativeResponseValue;
48415 // void RawDataPart_free(struct LDKRawDataPart this_obj);
48417 export function RawDataPart_free(this_obj: bigint): void {
48418 if(!isWasmInitialized) {
48419 throw new Error("initializeWasm() must be awaited first!");
48421 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
48422 // debug statements here
48424 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
48426 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
48427 if(!isWasmInitialized) {
48428 throw new Error("initializeWasm() must be awaited first!");
48430 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
48431 return nativeResponseValue;
48433 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
48435 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
48436 if(!isWasmInitialized) {
48437 throw new Error("initializeWasm() must be awaited first!");
48439 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
48440 // debug statements here
48442 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
48444 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
48445 if(!isWasmInitialized) {
48446 throw new Error("initializeWasm() must be awaited first!");
48448 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
48449 return nativeResponseValue;
48451 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
48453 export function RawDataPart_clone_ptr(arg: bigint): bigint {
48454 if(!isWasmInitialized) {
48455 throw new Error("initializeWasm() must be awaited first!");
48457 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
48458 return nativeResponseValue;
48460 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
48462 export function RawDataPart_clone(orig: bigint): bigint {
48463 if(!isWasmInitialized) {
48464 throw new Error("initializeWasm() must be awaited first!");
48466 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
48467 return nativeResponseValue;
48469 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
48471 export function RawDataPart_hash(o: bigint): bigint {
48472 if(!isWasmInitialized) {
48473 throw new Error("initializeWasm() must be awaited first!");
48475 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
48476 return nativeResponseValue;
48478 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
48480 export function PositiveTimestamp_free(this_obj: bigint): void {
48481 if(!isWasmInitialized) {
48482 throw new Error("initializeWasm() must be awaited first!");
48484 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
48485 // debug statements here
48487 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
48489 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
48490 if(!isWasmInitialized) {
48491 throw new Error("initializeWasm() must be awaited first!");
48493 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
48494 return nativeResponseValue;
48496 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
48498 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
48499 if(!isWasmInitialized) {
48500 throw new Error("initializeWasm() must be awaited first!");
48502 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
48503 return nativeResponseValue;
48505 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
48507 export function PositiveTimestamp_clone(orig: bigint): bigint {
48508 if(!isWasmInitialized) {
48509 throw new Error("initializeWasm() must be awaited first!");
48511 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
48512 return nativeResponseValue;
48514 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
48516 export function PositiveTimestamp_hash(o: bigint): bigint {
48517 if(!isWasmInitialized) {
48518 throw new Error("initializeWasm() must be awaited first!");
48520 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
48521 return nativeResponseValue;
48523 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
48525 export function SiPrefix_clone(orig: bigint): SiPrefix {
48526 if(!isWasmInitialized) {
48527 throw new Error("initializeWasm() must be awaited first!");
48529 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
48530 return nativeResponseValue;
48532 // enum LDKSiPrefix SiPrefix_milli(void);
48534 export function SiPrefix_milli(): SiPrefix {
48535 if(!isWasmInitialized) {
48536 throw new Error("initializeWasm() must be awaited first!");
48538 const nativeResponseValue = wasm.TS_SiPrefix_milli();
48539 return nativeResponseValue;
48541 // enum LDKSiPrefix SiPrefix_micro(void);
48543 export function SiPrefix_micro(): SiPrefix {
48544 if(!isWasmInitialized) {
48545 throw new Error("initializeWasm() must be awaited first!");
48547 const nativeResponseValue = wasm.TS_SiPrefix_micro();
48548 return nativeResponseValue;
48550 // enum LDKSiPrefix SiPrefix_nano(void);
48552 export function SiPrefix_nano(): SiPrefix {
48553 if(!isWasmInitialized) {
48554 throw new Error("initializeWasm() must be awaited first!");
48556 const nativeResponseValue = wasm.TS_SiPrefix_nano();
48557 return nativeResponseValue;
48559 // enum LDKSiPrefix SiPrefix_pico(void);
48561 export function SiPrefix_pico(): SiPrefix {
48562 if(!isWasmInitialized) {
48563 throw new Error("initializeWasm() must be awaited first!");
48565 const nativeResponseValue = wasm.TS_SiPrefix_pico();
48566 return nativeResponseValue;
48568 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
48570 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
48571 if(!isWasmInitialized) {
48572 throw new Error("initializeWasm() must be awaited first!");
48574 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
48575 return nativeResponseValue;
48577 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
48579 export function SiPrefix_hash(o: bigint): bigint {
48580 if(!isWasmInitialized) {
48581 throw new Error("initializeWasm() must be awaited first!");
48583 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
48584 return nativeResponseValue;
48586 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
48588 export function SiPrefix_multiplier(this_arg: bigint): bigint {
48589 if(!isWasmInitialized) {
48590 throw new Error("initializeWasm() must be awaited first!");
48592 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
48593 return nativeResponseValue;
48595 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
48597 export function Currency_clone(orig: bigint): Currency {
48598 if(!isWasmInitialized) {
48599 throw new Error("initializeWasm() must be awaited first!");
48601 const nativeResponseValue = wasm.TS_Currency_clone(orig);
48602 return nativeResponseValue;
48604 // enum LDKCurrency Currency_bitcoin(void);
48606 export function Currency_bitcoin(): Currency {
48607 if(!isWasmInitialized) {
48608 throw new Error("initializeWasm() must be awaited first!");
48610 const nativeResponseValue = wasm.TS_Currency_bitcoin();
48611 return nativeResponseValue;
48613 // enum LDKCurrency Currency_bitcoin_testnet(void);
48615 export function Currency_bitcoin_testnet(): Currency {
48616 if(!isWasmInitialized) {
48617 throw new Error("initializeWasm() must be awaited first!");
48619 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
48620 return nativeResponseValue;
48622 // enum LDKCurrency Currency_regtest(void);
48624 export function Currency_regtest(): Currency {
48625 if(!isWasmInitialized) {
48626 throw new Error("initializeWasm() must be awaited first!");
48628 const nativeResponseValue = wasm.TS_Currency_regtest();
48629 return nativeResponseValue;
48631 // enum LDKCurrency Currency_simnet(void);
48633 export function Currency_simnet(): Currency {
48634 if(!isWasmInitialized) {
48635 throw new Error("initializeWasm() must be awaited first!");
48637 const nativeResponseValue = wasm.TS_Currency_simnet();
48638 return nativeResponseValue;
48640 // enum LDKCurrency Currency_signet(void);
48642 export function Currency_signet(): Currency {
48643 if(!isWasmInitialized) {
48644 throw new Error("initializeWasm() must be awaited first!");
48646 const nativeResponseValue = wasm.TS_Currency_signet();
48647 return nativeResponseValue;
48649 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
48651 export function Currency_hash(o: bigint): bigint {
48652 if(!isWasmInitialized) {
48653 throw new Error("initializeWasm() must be awaited first!");
48655 const nativeResponseValue = wasm.TS_Currency_hash(o);
48656 return nativeResponseValue;
48658 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
48660 export function Currency_eq(a: bigint, b: bigint): boolean {
48661 if(!isWasmInitialized) {
48662 throw new Error("initializeWasm() must be awaited first!");
48664 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
48665 return nativeResponseValue;
48667 // void Sha256_free(struct LDKSha256 this_obj);
48669 export function Sha256_free(this_obj: bigint): void {
48670 if(!isWasmInitialized) {
48671 throw new Error("initializeWasm() must be awaited first!");
48673 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
48674 // debug statements here
48676 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
48678 export function Sha256_clone_ptr(arg: bigint): bigint {
48679 if(!isWasmInitialized) {
48680 throw new Error("initializeWasm() must be awaited first!");
48682 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
48683 return nativeResponseValue;
48685 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
48687 export function Sha256_clone(orig: bigint): bigint {
48688 if(!isWasmInitialized) {
48689 throw new Error("initializeWasm() must be awaited first!");
48691 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
48692 return nativeResponseValue;
48694 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
48696 export function Sha256_hash(o: bigint): bigint {
48697 if(!isWasmInitialized) {
48698 throw new Error("initializeWasm() must be awaited first!");
48700 const nativeResponseValue = wasm.TS_Sha256_hash(o);
48701 return nativeResponseValue;
48703 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
48705 export function Sha256_eq(a: bigint, b: bigint): boolean {
48706 if(!isWasmInitialized) {
48707 throw new Error("initializeWasm() must be awaited first!");
48709 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
48710 return nativeResponseValue;
48712 // MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
48714 export function Sha256_from_bytes(bytes: number): bigint {
48715 if(!isWasmInitialized) {
48716 throw new Error("initializeWasm() must be awaited first!");
48718 const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
48719 return nativeResponseValue;
48721 // void Description_free(struct LDKDescription this_obj);
48723 export function Description_free(this_obj: bigint): void {
48724 if(!isWasmInitialized) {
48725 throw new Error("initializeWasm() must be awaited first!");
48727 const nativeResponseValue = wasm.TS_Description_free(this_obj);
48728 // debug statements here
48730 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
48732 export function Description_clone_ptr(arg: bigint): bigint {
48733 if(!isWasmInitialized) {
48734 throw new Error("initializeWasm() must be awaited first!");
48736 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
48737 return nativeResponseValue;
48739 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
48741 export function Description_clone(orig: bigint): bigint {
48742 if(!isWasmInitialized) {
48743 throw new Error("initializeWasm() must be awaited first!");
48745 const nativeResponseValue = wasm.TS_Description_clone(orig);
48746 return nativeResponseValue;
48748 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
48750 export function Description_hash(o: bigint): bigint {
48751 if(!isWasmInitialized) {
48752 throw new Error("initializeWasm() must be awaited first!");
48754 const nativeResponseValue = wasm.TS_Description_hash(o);
48755 return nativeResponseValue;
48757 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
48759 export function Description_eq(a: bigint, b: bigint): boolean {
48760 if(!isWasmInitialized) {
48761 throw new Error("initializeWasm() must be awaited first!");
48763 const nativeResponseValue = wasm.TS_Description_eq(a, b);
48764 return nativeResponseValue;
48766 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
48768 export function PayeePubKey_free(this_obj: bigint): void {
48769 if(!isWasmInitialized) {
48770 throw new Error("initializeWasm() must be awaited first!");
48772 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
48773 // debug statements here
48775 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
48777 export function PayeePubKey_get_a(this_ptr: bigint): number {
48778 if(!isWasmInitialized) {
48779 throw new Error("initializeWasm() must be awaited first!");
48781 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
48782 return nativeResponseValue;
48784 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
48786 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
48787 if(!isWasmInitialized) {
48788 throw new Error("initializeWasm() must be awaited first!");
48790 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
48791 // debug statements here
48793 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
48795 export function PayeePubKey_new(a_arg: number): bigint {
48796 if(!isWasmInitialized) {
48797 throw new Error("initializeWasm() must be awaited first!");
48799 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
48800 return nativeResponseValue;
48802 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
48804 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
48805 if(!isWasmInitialized) {
48806 throw new Error("initializeWasm() must be awaited first!");
48808 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
48809 return nativeResponseValue;
48811 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
48813 export function PayeePubKey_clone(orig: bigint): bigint {
48814 if(!isWasmInitialized) {
48815 throw new Error("initializeWasm() must be awaited first!");
48817 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
48818 return nativeResponseValue;
48820 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
48822 export function PayeePubKey_hash(o: bigint): bigint {
48823 if(!isWasmInitialized) {
48824 throw new Error("initializeWasm() must be awaited first!");
48826 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
48827 return nativeResponseValue;
48829 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
48831 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
48832 if(!isWasmInitialized) {
48833 throw new Error("initializeWasm() must be awaited first!");
48835 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
48836 return nativeResponseValue;
48838 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
48840 export function ExpiryTime_free(this_obj: bigint): void {
48841 if(!isWasmInitialized) {
48842 throw new Error("initializeWasm() must be awaited first!");
48844 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
48845 // debug statements here
48847 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
48849 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
48850 if(!isWasmInitialized) {
48851 throw new Error("initializeWasm() must be awaited first!");
48853 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
48854 return nativeResponseValue;
48856 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
48858 export function ExpiryTime_clone(orig: bigint): bigint {
48859 if(!isWasmInitialized) {
48860 throw new Error("initializeWasm() must be awaited first!");
48862 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
48863 return nativeResponseValue;
48865 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
48867 export function ExpiryTime_hash(o: bigint): bigint {
48868 if(!isWasmInitialized) {
48869 throw new Error("initializeWasm() must be awaited first!");
48871 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
48872 return nativeResponseValue;
48874 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
48876 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
48877 if(!isWasmInitialized) {
48878 throw new Error("initializeWasm() must be awaited first!");
48880 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
48881 return nativeResponseValue;
48883 // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
48885 export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
48886 if(!isWasmInitialized) {
48887 throw new Error("initializeWasm() must be awaited first!");
48889 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
48890 // debug statements here
48892 // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
48894 export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
48895 if(!isWasmInitialized) {
48896 throw new Error("initializeWasm() must be awaited first!");
48898 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
48899 return nativeResponseValue;
48901 // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
48903 export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
48904 if(!isWasmInitialized) {
48905 throw new Error("initializeWasm() must be awaited first!");
48907 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
48908 // debug statements here
48910 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
48912 export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
48913 if(!isWasmInitialized) {
48914 throw new Error("initializeWasm() must be awaited first!");
48916 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
48917 return nativeResponseValue;
48919 // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
48921 export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
48922 if(!isWasmInitialized) {
48923 throw new Error("initializeWasm() must be awaited first!");
48925 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
48926 return nativeResponseValue;
48928 // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
48930 export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
48931 if(!isWasmInitialized) {
48932 throw new Error("initializeWasm() must be awaited first!");
48934 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
48935 return nativeResponseValue;
48937 // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
48939 export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
48940 if(!isWasmInitialized) {
48941 throw new Error("initializeWasm() must be awaited first!");
48943 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
48944 return nativeResponseValue;
48946 // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
48948 export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
48949 if(!isWasmInitialized) {
48950 throw new Error("initializeWasm() must be awaited first!");
48952 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
48953 return nativeResponseValue;
48955 // void Fallback_free(struct LDKFallback this_ptr);
48957 export function Fallback_free(this_ptr: bigint): void {
48958 if(!isWasmInitialized) {
48959 throw new Error("initializeWasm() must be awaited first!");
48961 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
48962 // debug statements here
48964 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
48966 export function Fallback_clone_ptr(arg: bigint): bigint {
48967 if(!isWasmInitialized) {
48968 throw new Error("initializeWasm() must be awaited first!");
48970 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
48971 return nativeResponseValue;
48973 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
48975 export function Fallback_clone(orig: bigint): bigint {
48976 if(!isWasmInitialized) {
48977 throw new Error("initializeWasm() must be awaited first!");
48979 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
48980 return nativeResponseValue;
48982 // struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
48984 export function Fallback_seg_wit_program(version: number, program: number): bigint {
48985 if(!isWasmInitialized) {
48986 throw new Error("initializeWasm() must be awaited first!");
48988 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
48989 return nativeResponseValue;
48991 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
48993 export function Fallback_pub_key_hash(a: number): bigint {
48994 if(!isWasmInitialized) {
48995 throw new Error("initializeWasm() must be awaited first!");
48997 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
48998 return nativeResponseValue;
49000 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
49002 export function Fallback_script_hash(a: number): bigint {
49003 if(!isWasmInitialized) {
49004 throw new Error("initializeWasm() must be awaited first!");
49006 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
49007 return nativeResponseValue;
49009 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
49011 export function Fallback_hash(o: bigint): bigint {
49012 if(!isWasmInitialized) {
49013 throw new Error("initializeWasm() must be awaited first!");
49015 const nativeResponseValue = wasm.TS_Fallback_hash(o);
49016 return nativeResponseValue;
49018 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
49020 export function Fallback_eq(a: bigint, b: bigint): boolean {
49021 if(!isWasmInitialized) {
49022 throw new Error("initializeWasm() must be awaited first!");
49024 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
49025 return nativeResponseValue;
49027 // void Bolt11InvoiceSignature_free(struct LDKBolt11InvoiceSignature this_obj);
49029 export function Bolt11InvoiceSignature_free(this_obj: bigint): void {
49030 if(!isWasmInitialized) {
49031 throw new Error("initializeWasm() must be awaited first!");
49033 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_free(this_obj);
49034 // debug statements here
49036 // uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg);
49038 export function Bolt11InvoiceSignature_clone_ptr(arg: bigint): bigint {
49039 if(!isWasmInitialized) {
49040 throw new Error("initializeWasm() must be awaited first!");
49042 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone_ptr(arg);
49043 return nativeResponseValue;
49045 // struct LDKBolt11InvoiceSignature Bolt11InvoiceSignature_clone(const struct LDKBolt11InvoiceSignature *NONNULL_PTR orig);
49047 export function Bolt11InvoiceSignature_clone(orig: bigint): bigint {
49048 if(!isWasmInitialized) {
49049 throw new Error("initializeWasm() must be awaited first!");
49051 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone(orig);
49052 return nativeResponseValue;
49054 // uint64_t Bolt11InvoiceSignature_hash(const struct LDKBolt11InvoiceSignature *NONNULL_PTR o);
49056 export function Bolt11InvoiceSignature_hash(o: bigint): bigint {
49057 if(!isWasmInitialized) {
49058 throw new Error("initializeWasm() must be awaited first!");
49060 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_hash(o);
49061 return nativeResponseValue;
49063 // bool Bolt11InvoiceSignature_eq(const struct LDKBolt11InvoiceSignature *NONNULL_PTR a, const struct LDKBolt11InvoiceSignature *NONNULL_PTR b);
49065 export function Bolt11InvoiceSignature_eq(a: bigint, b: bigint): boolean {
49066 if(!isWasmInitialized) {
49067 throw new Error("initializeWasm() must be awaited first!");
49069 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_eq(a, b);
49070 return nativeResponseValue;
49072 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
49074 export function PrivateRoute_free(this_obj: bigint): void {
49075 if(!isWasmInitialized) {
49076 throw new Error("initializeWasm() must be awaited first!");
49078 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
49079 // debug statements here
49081 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
49083 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
49084 if(!isWasmInitialized) {
49085 throw new Error("initializeWasm() must be awaited first!");
49087 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
49088 return nativeResponseValue;
49090 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
49092 export function PrivateRoute_clone(orig: bigint): bigint {
49093 if(!isWasmInitialized) {
49094 throw new Error("initializeWasm() must be awaited first!");
49096 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
49097 return nativeResponseValue;
49099 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
49101 export function PrivateRoute_hash(o: bigint): bigint {
49102 if(!isWasmInitialized) {
49103 throw new Error("initializeWasm() must be awaited first!");
49105 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
49106 return nativeResponseValue;
49108 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
49110 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
49111 if(!isWasmInitialized) {
49112 throw new Error("initializeWasm() must be awaited first!");
49114 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
49115 return nativeResponseValue;
49117 // MUST_USE_RES struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ SignedRawBolt11Invoice_into_parts(struct LDKSignedRawBolt11Invoice this_arg);
49119 export function SignedRawBolt11Invoice_into_parts(this_arg: bigint): bigint {
49120 if(!isWasmInitialized) {
49121 throw new Error("initializeWasm() must be awaited first!");
49123 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_into_parts(this_arg);
49124 return nativeResponseValue;
49126 // MUST_USE_RES struct LDKRawBolt11Invoice SignedRawBolt11Invoice_raw_invoice(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
49128 export function SignedRawBolt11Invoice_raw_invoice(this_arg: bigint): bigint {
49129 if(!isWasmInitialized) {
49130 throw new Error("initializeWasm() must be awaited first!");
49132 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_raw_invoice(this_arg);
49133 return nativeResponseValue;
49135 // MUST_USE_RES const uint8_t (*SignedRawBolt11Invoice_signable_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg))[32];
49137 export function SignedRawBolt11Invoice_signable_hash(this_arg: bigint): number {
49138 if(!isWasmInitialized) {
49139 throw new Error("initializeWasm() must be awaited first!");
49141 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signable_hash(this_arg);
49142 return nativeResponseValue;
49144 // MUST_USE_RES struct LDKBolt11InvoiceSignature SignedRawBolt11Invoice_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
49146 export function SignedRawBolt11Invoice_signature(this_arg: bigint): bigint {
49147 if(!isWasmInitialized) {
49148 throw new Error("initializeWasm() must be awaited first!");
49150 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signature(this_arg);
49151 return nativeResponseValue;
49153 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawBolt11Invoice_recover_payee_pub_key(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
49155 export function SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: bigint): bigint {
49156 if(!isWasmInitialized) {
49157 throw new Error("initializeWasm() must be awaited first!");
49159 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_recover_payee_pub_key(this_arg);
49160 return nativeResponseValue;
49162 // MUST_USE_RES bool SignedRawBolt11Invoice_check_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
49164 export function SignedRawBolt11Invoice_check_signature(this_arg: bigint): boolean {
49165 if(!isWasmInitialized) {
49166 throw new Error("initializeWasm() must be awaited first!");
49168 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_check_signature(this_arg);
49169 return nativeResponseValue;
49171 // MUST_USE_RES struct LDKThirtyTwoBytes RawBolt11Invoice_signable_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49173 export function RawBolt11Invoice_signable_hash(this_arg: bigint): number {
49174 if(!isWasmInitialized) {
49175 throw new Error("initializeWasm() must be awaited first!");
49177 const nativeResponseValue = wasm.TS_RawBolt11Invoice_signable_hash(this_arg);
49178 return nativeResponseValue;
49180 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_payment_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49182 export function RawBolt11Invoice_payment_hash(this_arg: bigint): bigint {
49183 if(!isWasmInitialized) {
49184 throw new Error("initializeWasm() must be awaited first!");
49186 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_hash(this_arg);
49187 return nativeResponseValue;
49189 // MUST_USE_RES struct LDKDescription RawBolt11Invoice_description(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49191 export function RawBolt11Invoice_description(this_arg: bigint): bigint {
49192 if(!isWasmInitialized) {
49193 throw new Error("initializeWasm() must be awaited first!");
49195 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description(this_arg);
49196 return nativeResponseValue;
49198 // MUST_USE_RES struct LDKPayeePubKey RawBolt11Invoice_payee_pub_key(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49200 export function RawBolt11Invoice_payee_pub_key(this_arg: bigint): bigint {
49201 if(!isWasmInitialized) {
49202 throw new Error("initializeWasm() must be awaited first!");
49204 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payee_pub_key(this_arg);
49205 return nativeResponseValue;
49207 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_description_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49209 export function RawBolt11Invoice_description_hash(this_arg: bigint): bigint {
49210 if(!isWasmInitialized) {
49211 throw new Error("initializeWasm() must be awaited first!");
49213 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description_hash(this_arg);
49214 return nativeResponseValue;
49216 // MUST_USE_RES struct LDKExpiryTime RawBolt11Invoice_expiry_time(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49218 export function RawBolt11Invoice_expiry_time(this_arg: bigint): bigint {
49219 if(!isWasmInitialized) {
49220 throw new Error("initializeWasm() must be awaited first!");
49222 const nativeResponseValue = wasm.TS_RawBolt11Invoice_expiry_time(this_arg);
49223 return nativeResponseValue;
49225 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawBolt11Invoice_min_final_cltv_expiry_delta(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49227 export function RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
49228 if(!isWasmInitialized) {
49229 throw new Error("initializeWasm() must be awaited first!");
49231 const nativeResponseValue = wasm.TS_RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg);
49232 return nativeResponseValue;
49234 // MUST_USE_RES struct LDKCOption_PaymentSecretZ RawBolt11Invoice_payment_secret(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49236 export function RawBolt11Invoice_payment_secret(this_arg: bigint): bigint {
49237 if(!isWasmInitialized) {
49238 throw new Error("initializeWasm() must be awaited first!");
49240 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_secret(this_arg);
49241 return nativeResponseValue;
49243 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawBolt11Invoice_payment_metadata(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49245 export function RawBolt11Invoice_payment_metadata(this_arg: bigint): bigint {
49246 if(!isWasmInitialized) {
49247 throw new Error("initializeWasm() must be awaited first!");
49249 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_metadata(this_arg);
49250 return nativeResponseValue;
49252 // MUST_USE_RES struct LDKBolt11InvoiceFeatures RawBolt11Invoice_features(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49254 export function RawBolt11Invoice_features(this_arg: bigint): bigint {
49255 if(!isWasmInitialized) {
49256 throw new Error("initializeWasm() must be awaited first!");
49258 const nativeResponseValue = wasm.TS_RawBolt11Invoice_features(this_arg);
49259 return nativeResponseValue;
49261 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawBolt11Invoice_private_routes(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49263 export function RawBolt11Invoice_private_routes(this_arg: bigint): number {
49264 if(!isWasmInitialized) {
49265 throw new Error("initializeWasm() must be awaited first!");
49267 const nativeResponseValue = wasm.TS_RawBolt11Invoice_private_routes(this_arg);
49268 return nativeResponseValue;
49270 // MUST_USE_RES struct LDKCOption_u64Z RawBolt11Invoice_amount_pico_btc(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49272 export function RawBolt11Invoice_amount_pico_btc(this_arg: bigint): bigint {
49273 if(!isWasmInitialized) {
49274 throw new Error("initializeWasm() must be awaited first!");
49276 const nativeResponseValue = wasm.TS_RawBolt11Invoice_amount_pico_btc(this_arg);
49277 return nativeResponseValue;
49279 // MUST_USE_RES enum LDKCurrency RawBolt11Invoice_currency(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
49281 export function RawBolt11Invoice_currency(this_arg: bigint): Currency {
49282 if(!isWasmInitialized) {
49283 throw new Error("initializeWasm() must be awaited first!");
49285 const nativeResponseValue = wasm.TS_RawBolt11Invoice_currency(this_arg);
49286 return nativeResponseValue;
49288 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
49290 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
49291 if(!isWasmInitialized) {
49292 throw new Error("initializeWasm() must be awaited first!");
49294 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
49295 return nativeResponseValue;
49297 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
49299 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
49300 if(!isWasmInitialized) {
49301 throw new Error("initializeWasm() must be awaited first!");
49303 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
49304 return nativeResponseValue;
49306 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
49308 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
49309 if(!isWasmInitialized) {
49310 throw new Error("initializeWasm() must be awaited first!");
49312 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
49313 return nativeResponseValue;
49315 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
49317 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
49318 if(!isWasmInitialized) {
49319 throw new Error("initializeWasm() must be awaited first!");
49321 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
49322 return nativeResponseValue;
49324 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt11Invoice_signable_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49326 export function Bolt11Invoice_signable_hash(this_arg: bigint): number {
49327 if(!isWasmInitialized) {
49328 throw new Error("initializeWasm() must be awaited first!");
49330 const nativeResponseValue = wasm.TS_Bolt11Invoice_signable_hash(this_arg);
49331 return nativeResponseValue;
49333 // MUST_USE_RES struct LDKSignedRawBolt11Invoice Bolt11Invoice_into_signed_raw(struct LDKBolt11Invoice this_arg);
49335 export function Bolt11Invoice_into_signed_raw(this_arg: bigint): bigint {
49336 if(!isWasmInitialized) {
49337 throw new Error("initializeWasm() must be awaited first!");
49339 const nativeResponseValue = wasm.TS_Bolt11Invoice_into_signed_raw(this_arg);
49340 return nativeResponseValue;
49342 // MUST_USE_RES struct LDKCResult_NoneBolt11SemanticErrorZ Bolt11Invoice_check_signature(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49344 export function Bolt11Invoice_check_signature(this_arg: bigint): bigint {
49345 if(!isWasmInitialized) {
49346 throw new Error("initializeWasm() must be awaited first!");
49348 const nativeResponseValue = wasm.TS_Bolt11Invoice_check_signature(this_arg);
49349 return nativeResponseValue;
49351 // MUST_USE_RES struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ Bolt11Invoice_from_signed(struct LDKSignedRawBolt11Invoice signed_invoice);
49353 export function Bolt11Invoice_from_signed(signed_invoice: bigint): bigint {
49354 if(!isWasmInitialized) {
49355 throw new Error("initializeWasm() must be awaited first!");
49357 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_signed(signed_invoice);
49358 return nativeResponseValue;
49360 // MUST_USE_RES uint64_t Bolt11Invoice_duration_since_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49362 export function Bolt11Invoice_duration_since_epoch(this_arg: bigint): bigint {
49363 if(!isWasmInitialized) {
49364 throw new Error("initializeWasm() must be awaited first!");
49366 const nativeResponseValue = wasm.TS_Bolt11Invoice_duration_since_epoch(this_arg);
49367 return nativeResponseValue;
49369 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
49371 export function Bolt11Invoice_payment_hash(this_arg: bigint): number {
49372 if(!isWasmInitialized) {
49373 throw new Error("initializeWasm() must be awaited first!");
49375 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_hash(this_arg);
49376 return nativeResponseValue;
49378 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49380 export function Bolt11Invoice_payee_pub_key(this_arg: bigint): number {
49381 if(!isWasmInitialized) {
49382 throw new Error("initializeWasm() must be awaited first!");
49384 const nativeResponseValue = wasm.TS_Bolt11Invoice_payee_pub_key(this_arg);
49385 return nativeResponseValue;
49387 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_secret(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
49389 export function Bolt11Invoice_payment_secret(this_arg: bigint): number {
49390 if(!isWasmInitialized) {
49391 throw new Error("initializeWasm() must be awaited first!");
49393 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_secret(this_arg);
49394 return nativeResponseValue;
49396 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt11Invoice_payment_metadata(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49398 export function Bolt11Invoice_payment_metadata(this_arg: bigint): bigint {
49399 if(!isWasmInitialized) {
49400 throw new Error("initializeWasm() must be awaited first!");
49402 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_metadata(this_arg);
49403 return nativeResponseValue;
49405 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11Invoice_features(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49407 export function Bolt11Invoice_features(this_arg: bigint): bigint {
49408 if(!isWasmInitialized) {
49409 throw new Error("initializeWasm() must be awaited first!");
49411 const nativeResponseValue = wasm.TS_Bolt11Invoice_features(this_arg);
49412 return nativeResponseValue;
49414 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_recover_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49416 export function Bolt11Invoice_recover_payee_pub_key(this_arg: bigint): number {
49417 if(!isWasmInitialized) {
49418 throw new Error("initializeWasm() must be awaited first!");
49420 const nativeResponseValue = wasm.TS_Bolt11Invoice_recover_payee_pub_key(this_arg);
49421 return nativeResponseValue;
49423 // MUST_USE_RES struct LDKCOption_DurationZ Bolt11Invoice_expires_at(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49425 export function Bolt11Invoice_expires_at(this_arg: bigint): bigint {
49426 if(!isWasmInitialized) {
49427 throw new Error("initializeWasm() must be awaited first!");
49429 const nativeResponseValue = wasm.TS_Bolt11Invoice_expires_at(this_arg);
49430 return nativeResponseValue;
49432 // MUST_USE_RES uint64_t Bolt11Invoice_expiry_time(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49434 export function Bolt11Invoice_expiry_time(this_arg: bigint): bigint {
49435 if(!isWasmInitialized) {
49436 throw new Error("initializeWasm() must be awaited first!");
49438 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiry_time(this_arg);
49439 return nativeResponseValue;
49441 // MUST_USE_RES uint64_t Bolt11Invoice_expiration_remaining_from_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t time);
49443 export function Bolt11Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
49444 if(!isWasmInitialized) {
49445 throw new Error("initializeWasm() must be awaited first!");
49447 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiration_remaining_from_epoch(this_arg, time);
49448 return nativeResponseValue;
49450 // MUST_USE_RES bool Bolt11Invoice_would_expire(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t at_time);
49452 export function Bolt11Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
49453 if(!isWasmInitialized) {
49454 throw new Error("initializeWasm() must be awaited first!");
49456 const nativeResponseValue = wasm.TS_Bolt11Invoice_would_expire(this_arg, at_time);
49457 return nativeResponseValue;
49459 // MUST_USE_RES uint64_t Bolt11Invoice_min_final_cltv_expiry_delta(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49461 export function Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
49462 if(!isWasmInitialized) {
49463 throw new Error("initializeWasm() must be awaited first!");
49465 const nativeResponseValue = wasm.TS_Bolt11Invoice_min_final_cltv_expiry_delta(this_arg);
49466 return nativeResponseValue;
49468 // MUST_USE_RES struct LDKCVec_AddressZ Bolt11Invoice_fallback_addresses(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49470 export function Bolt11Invoice_fallback_addresses(this_arg: bigint): number {
49471 if(!isWasmInitialized) {
49472 throw new Error("initializeWasm() must be awaited first!");
49474 const nativeResponseValue = wasm.TS_Bolt11Invoice_fallback_addresses(this_arg);
49475 return nativeResponseValue;
49477 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Bolt11Invoice_private_routes(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49479 export function Bolt11Invoice_private_routes(this_arg: bigint): number {
49480 if(!isWasmInitialized) {
49481 throw new Error("initializeWasm() must be awaited first!");
49483 const nativeResponseValue = wasm.TS_Bolt11Invoice_private_routes(this_arg);
49484 return nativeResponseValue;
49486 // MUST_USE_RES struct LDKCVec_RouteHintZ Bolt11Invoice_route_hints(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49488 export function Bolt11Invoice_route_hints(this_arg: bigint): number {
49489 if(!isWasmInitialized) {
49490 throw new Error("initializeWasm() must be awaited first!");
49492 const nativeResponseValue = wasm.TS_Bolt11Invoice_route_hints(this_arg);
49493 return nativeResponseValue;
49495 // MUST_USE_RES enum LDKCurrency Bolt11Invoice_currency(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49497 export function Bolt11Invoice_currency(this_arg: bigint): Currency {
49498 if(!isWasmInitialized) {
49499 throw new Error("initializeWasm() must be awaited first!");
49501 const nativeResponseValue = wasm.TS_Bolt11Invoice_currency(this_arg);
49502 return nativeResponseValue;
49504 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_amount_milli_satoshis(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
49506 export function Bolt11Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
49507 if(!isWasmInitialized) {
49508 throw new Error("initializeWasm() must be awaited first!");
49510 const nativeResponseValue = wasm.TS_Bolt11Invoice_amount_milli_satoshis(this_arg);
49511 return nativeResponseValue;
49513 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
49515 export function Description_new(description: number): bigint {
49516 if(!isWasmInitialized) {
49517 throw new Error("initializeWasm() must be awaited first!");
49519 const nativeResponseValue = wasm.TS_Description_new(description);
49520 return nativeResponseValue;
49522 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
49524 export function Description_into_inner(this_arg: bigint): number {
49525 if(!isWasmInitialized) {
49526 throw new Error("initializeWasm() must be awaited first!");
49528 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
49529 return nativeResponseValue;
49531 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
49533 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
49534 if(!isWasmInitialized) {
49535 throw new Error("initializeWasm() must be awaited first!");
49537 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
49538 return nativeResponseValue;
49540 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
49542 export function ExpiryTime_from_duration(duration: bigint): bigint {
49543 if(!isWasmInitialized) {
49544 throw new Error("initializeWasm() must be awaited first!");
49546 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
49547 return nativeResponseValue;
49549 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
49551 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
49552 if(!isWasmInitialized) {
49553 throw new Error("initializeWasm() must be awaited first!");
49555 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
49556 return nativeResponseValue;
49558 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
49560 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
49561 if(!isWasmInitialized) {
49562 throw new Error("initializeWasm() must be awaited first!");
49564 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
49565 return nativeResponseValue;
49567 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
49569 export function PrivateRoute_new(hops: bigint): bigint {
49570 if(!isWasmInitialized) {
49571 throw new Error("initializeWasm() must be awaited first!");
49573 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
49574 return nativeResponseValue;
49576 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
49578 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
49579 if(!isWasmInitialized) {
49580 throw new Error("initializeWasm() must be awaited first!");
49582 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
49583 return nativeResponseValue;
49585 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
49587 export function CreationError_clone(orig: bigint): CreationError {
49588 if(!isWasmInitialized) {
49589 throw new Error("initializeWasm() must be awaited first!");
49591 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
49592 return nativeResponseValue;
49594 // enum LDKCreationError CreationError_description_too_long(void);
49596 export function CreationError_description_too_long(): CreationError {
49597 if(!isWasmInitialized) {
49598 throw new Error("initializeWasm() must be awaited first!");
49600 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
49601 return nativeResponseValue;
49603 // enum LDKCreationError CreationError_route_too_long(void);
49605 export function CreationError_route_too_long(): CreationError {
49606 if(!isWasmInitialized) {
49607 throw new Error("initializeWasm() must be awaited first!");
49609 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
49610 return nativeResponseValue;
49612 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
49614 export function CreationError_timestamp_out_of_bounds(): CreationError {
49615 if(!isWasmInitialized) {
49616 throw new Error("initializeWasm() must be awaited first!");
49618 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
49619 return nativeResponseValue;
49621 // enum LDKCreationError CreationError_invalid_amount(void);
49623 export function CreationError_invalid_amount(): CreationError {
49624 if(!isWasmInitialized) {
49625 throw new Error("initializeWasm() must be awaited first!");
49627 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
49628 return nativeResponseValue;
49630 // enum LDKCreationError CreationError_missing_route_hints(void);
49632 export function CreationError_missing_route_hints(): CreationError {
49633 if(!isWasmInitialized) {
49634 throw new Error("initializeWasm() must be awaited first!");
49636 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
49637 return nativeResponseValue;
49639 // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
49641 export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
49642 if(!isWasmInitialized) {
49643 throw new Error("initializeWasm() must be awaited first!");
49645 const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
49646 return nativeResponseValue;
49648 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
49650 export function CreationError_eq(a: bigint, b: bigint): boolean {
49651 if(!isWasmInitialized) {
49652 throw new Error("initializeWasm() must be awaited first!");
49654 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
49655 return nativeResponseValue;
49657 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
49659 export function CreationError_to_str(o: bigint): number {
49660 if(!isWasmInitialized) {
49661 throw new Error("initializeWasm() must be awaited first!");
49663 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
49664 return nativeResponseValue;
49666 // enum LDKBolt11SemanticError Bolt11SemanticError_clone(const enum LDKBolt11SemanticError *NONNULL_PTR orig);
49668 export function Bolt11SemanticError_clone(orig: bigint): Bolt11SemanticError {
49669 if(!isWasmInitialized) {
49670 throw new Error("initializeWasm() must be awaited first!");
49672 const nativeResponseValue = wasm.TS_Bolt11SemanticError_clone(orig);
49673 return nativeResponseValue;
49675 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_hash(void);
49677 export function Bolt11SemanticError_no_payment_hash(): Bolt11SemanticError {
49678 if(!isWasmInitialized) {
49679 throw new Error("initializeWasm() must be awaited first!");
49681 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_hash();
49682 return nativeResponseValue;
49684 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_hashes(void);
49686 export function Bolt11SemanticError_multiple_payment_hashes(): Bolt11SemanticError {
49687 if(!isWasmInitialized) {
49688 throw new Error("initializeWasm() must be awaited first!");
49690 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_hashes();
49691 return nativeResponseValue;
49693 // enum LDKBolt11SemanticError Bolt11SemanticError_no_description(void);
49695 export function Bolt11SemanticError_no_description(): Bolt11SemanticError {
49696 if(!isWasmInitialized) {
49697 throw new Error("initializeWasm() must be awaited first!");
49699 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_description();
49700 return nativeResponseValue;
49702 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_descriptions(void);
49704 export function Bolt11SemanticError_multiple_descriptions(): Bolt11SemanticError {
49705 if(!isWasmInitialized) {
49706 throw new Error("initializeWasm() must be awaited first!");
49708 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_descriptions();
49709 return nativeResponseValue;
49711 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_secret(void);
49713 export function Bolt11SemanticError_no_payment_secret(): Bolt11SemanticError {
49714 if(!isWasmInitialized) {
49715 throw new Error("initializeWasm() must be awaited first!");
49717 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_secret();
49718 return nativeResponseValue;
49720 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_secrets(void);
49722 export function Bolt11SemanticError_multiple_payment_secrets(): Bolt11SemanticError {
49723 if(!isWasmInitialized) {
49724 throw new Error("initializeWasm() must be awaited first!");
49726 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_secrets();
49727 return nativeResponseValue;
49729 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_features(void);
49731 export function Bolt11SemanticError_invalid_features(): Bolt11SemanticError {
49732 if(!isWasmInitialized) {
49733 throw new Error("initializeWasm() must be awaited first!");
49735 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_features();
49736 return nativeResponseValue;
49738 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_recovery_id(void);
49740 export function Bolt11SemanticError_invalid_recovery_id(): Bolt11SemanticError {
49741 if(!isWasmInitialized) {
49742 throw new Error("initializeWasm() must be awaited first!");
49744 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_recovery_id();
49745 return nativeResponseValue;
49747 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_signature(void);
49749 export function Bolt11SemanticError_invalid_signature(): Bolt11SemanticError {
49750 if(!isWasmInitialized) {
49751 throw new Error("initializeWasm() must be awaited first!");
49753 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_signature();
49754 return nativeResponseValue;
49756 // enum LDKBolt11SemanticError Bolt11SemanticError_imprecise_amount(void);
49758 export function Bolt11SemanticError_imprecise_amount(): Bolt11SemanticError {
49759 if(!isWasmInitialized) {
49760 throw new Error("initializeWasm() must be awaited first!");
49762 const nativeResponseValue = wasm.TS_Bolt11SemanticError_imprecise_amount();
49763 return nativeResponseValue;
49765 // bool Bolt11SemanticError_eq(const enum LDKBolt11SemanticError *NONNULL_PTR a, const enum LDKBolt11SemanticError *NONNULL_PTR b);
49767 export function Bolt11SemanticError_eq(a: bigint, b: bigint): boolean {
49768 if(!isWasmInitialized) {
49769 throw new Error("initializeWasm() must be awaited first!");
49771 const nativeResponseValue = wasm.TS_Bolt11SemanticError_eq(a, b);
49772 return nativeResponseValue;
49774 // struct LDKStr Bolt11SemanticError_to_str(const enum LDKBolt11SemanticError *NONNULL_PTR o);
49776 export function Bolt11SemanticError_to_str(o: bigint): number {
49777 if(!isWasmInitialized) {
49778 throw new Error("initializeWasm() must be awaited first!");
49780 const nativeResponseValue = wasm.TS_Bolt11SemanticError_to_str(o);
49781 return nativeResponseValue;
49783 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
49785 export function SignOrCreationError_free(this_ptr: bigint): void {
49786 if(!isWasmInitialized) {
49787 throw new Error("initializeWasm() must be awaited first!");
49789 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
49790 // debug statements here
49792 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
49794 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
49795 if(!isWasmInitialized) {
49796 throw new Error("initializeWasm() must be awaited first!");
49798 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
49799 return nativeResponseValue;
49801 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
49803 export function SignOrCreationError_clone(orig: bigint): bigint {
49804 if(!isWasmInitialized) {
49805 throw new Error("initializeWasm() must be awaited first!");
49807 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
49808 return nativeResponseValue;
49810 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
49812 export function SignOrCreationError_sign_error(): bigint {
49813 if(!isWasmInitialized) {
49814 throw new Error("initializeWasm() must be awaited first!");
49816 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
49817 return nativeResponseValue;
49819 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
49821 export function SignOrCreationError_creation_error(a: CreationError): bigint {
49822 if(!isWasmInitialized) {
49823 throw new Error("initializeWasm() must be awaited first!");
49825 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
49826 return nativeResponseValue;
49828 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
49830 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
49831 if(!isWasmInitialized) {
49832 throw new Error("initializeWasm() must be awaited first!");
49834 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
49835 return nativeResponseValue;
49837 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
49839 export function SignOrCreationError_to_str(o: bigint): number {
49840 if(!isWasmInitialized) {
49841 throw new Error("initializeWasm() must be awaited first!");
49843 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
49844 return nativeResponseValue;
49846 // struct LDKCResult_PaymentIdPaymentErrorZ pay_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
49848 export function pay_invoice(invoice: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
49849 if(!isWasmInitialized) {
49850 throw new Error("initializeWasm() must be awaited first!");
49852 const nativeResponseValue = wasm.TS_pay_invoice(invoice, retry_strategy, channelmanager);
49853 return nativeResponseValue;
49855 // struct LDKCResult_NonePaymentErrorZ pay_invoice_with_id(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
49857 export function pay_invoice_with_id(invoice: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
49858 if(!isWasmInitialized) {
49859 throw new Error("initializeWasm() must be awaited first!");
49861 const nativeResponseValue = wasm.TS_pay_invoice_with_id(invoice, payment_id, retry_strategy, channelmanager);
49862 return nativeResponseValue;
49864 // struct LDKCResult_PaymentIdPaymentErrorZ pay_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
49866 export function pay_zero_value_invoice(invoice: bigint, amount_msats: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
49867 if(!isWasmInitialized) {
49868 throw new Error("initializeWasm() must be awaited first!");
49870 const nativeResponseValue = wasm.TS_pay_zero_value_invoice(invoice, amount_msats, retry_strategy, channelmanager);
49871 return nativeResponseValue;
49873 // struct LDKCResult_NonePaymentErrorZ pay_zero_value_invoice_with_id(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
49875 export function pay_zero_value_invoice_with_id(invoice: bigint, amount_msats: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
49876 if(!isWasmInitialized) {
49877 throw new Error("initializeWasm() must be awaited first!");
49879 const nativeResponseValue = wasm.TS_pay_zero_value_invoice_with_id(invoice, amount_msats, payment_id, retry_strategy, channelmanager);
49880 return nativeResponseValue;
49882 // void PaymentError_free(struct LDKPaymentError this_ptr);
49884 export function PaymentError_free(this_ptr: bigint): void {
49885 if(!isWasmInitialized) {
49886 throw new Error("initializeWasm() must be awaited first!");
49888 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
49889 // debug statements here
49891 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
49893 export function PaymentError_clone_ptr(arg: bigint): bigint {
49894 if(!isWasmInitialized) {
49895 throw new Error("initializeWasm() must be awaited first!");
49897 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
49898 return nativeResponseValue;
49900 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
49902 export function PaymentError_clone(orig: bigint): bigint {
49903 if(!isWasmInitialized) {
49904 throw new Error("initializeWasm() must be awaited first!");
49906 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
49907 return nativeResponseValue;
49909 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
49911 export function PaymentError_invoice(a: number): bigint {
49912 if(!isWasmInitialized) {
49913 throw new Error("initializeWasm() must be awaited first!");
49915 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
49916 return nativeResponseValue;
49918 // struct LDKPaymentError PaymentError_sending(enum LDKRetryableSendFailure a);
49920 export function PaymentError_sending(a: RetryableSendFailure): bigint {
49921 if(!isWasmInitialized) {
49922 throw new Error("initializeWasm() must be awaited first!");
49924 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
49925 return nativeResponseValue;
49927 // bool PaymentError_eq(const struct LDKPaymentError *NONNULL_PTR a, const struct LDKPaymentError *NONNULL_PTR b);
49929 export function PaymentError_eq(a: bigint, b: bigint): boolean {
49930 if(!isWasmInitialized) {
49931 throw new Error("initializeWasm() must be awaited first!");
49933 const nativeResponseValue = wasm.TS_PaymentError_eq(a, b);
49934 return nativeResponseValue;
49936 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice(struct LDKCOption_u64Z amt_msat, struct LDKCOption_PaymentHashZ 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);
49938 export function create_phantom_invoice(amt_msat: bigint, payment_hash: bigint, 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 {
49939 if(!isWasmInitialized) {
49940 throw new Error("initializeWasm() must be awaited first!");
49942 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);
49943 return nativeResponseValue;
49945 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice_with_description_hash(struct LDKCOption_u64Z amt_msat, struct LDKCOption_PaymentHashZ 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);
49947 export function create_phantom_invoice_with_description_hash(amt_msat: bigint, payment_hash: bigint, 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 {
49948 if(!isWasmInitialized) {
49949 throw new Error("initializeWasm() must be awaited first!");
49951 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);
49952 return nativeResponseValue;
49954 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ 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);
49956 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 {
49957 if(!isWasmInitialized) {
49958 throw new Error("initializeWasm() must be awaited first!");
49960 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);
49961 return nativeResponseValue;
49963 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ 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);
49965 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 {
49966 if(!isWasmInitialized) {
49967 throw new Error("initializeWasm() must be awaited first!");
49969 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);
49970 return nativeResponseValue;
49972 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ 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);
49974 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 {
49975 if(!isWasmInitialized) {
49976 throw new Error("initializeWasm() must be awaited first!");
49978 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);
49979 return nativeResponseValue;
49981 // struct LDKCResult_SiPrefixBolt11ParseErrorZ SiPrefix_from_str(struct LDKStr s);
49983 export function SiPrefix_from_str(s: number): bigint {
49984 if(!isWasmInitialized) {
49985 throw new Error("initializeWasm() must be awaited first!");
49987 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
49988 return nativeResponseValue;
49990 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ Bolt11Invoice_from_str(struct LDKStr s);
49992 export function Bolt11Invoice_from_str(s: number): bigint {
49993 if(!isWasmInitialized) {
49994 throw new Error("initializeWasm() must be awaited first!");
49996 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_str(s);
49997 return nativeResponseValue;
49999 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ SignedRawBolt11Invoice_from_str(struct LDKStr s);
50001 export function SignedRawBolt11Invoice_from_str(s: number): bigint {
50002 if(!isWasmInitialized) {
50003 throw new Error("initializeWasm() must be awaited first!");
50005 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_from_str(s);
50006 return nativeResponseValue;
50008 // struct LDKStr Bolt11ParseError_to_str(const struct LDKBolt11ParseError *NONNULL_PTR o);
50010 export function Bolt11ParseError_to_str(o: bigint): number {
50011 if(!isWasmInitialized) {
50012 throw new Error("initializeWasm() must be awaited first!");
50014 const nativeResponseValue = wasm.TS_Bolt11ParseError_to_str(o);
50015 return nativeResponseValue;
50017 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
50019 export function ParseOrSemanticError_to_str(o: bigint): number {
50020 if(!isWasmInitialized) {
50021 throw new Error("initializeWasm() must be awaited first!");
50023 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
50024 return nativeResponseValue;
50026 // struct LDKStr Bolt11Invoice_to_str(const struct LDKBolt11Invoice *NONNULL_PTR o);
50028 export function Bolt11Invoice_to_str(o: bigint): number {
50029 if(!isWasmInitialized) {
50030 throw new Error("initializeWasm() must be awaited first!");
50032 const nativeResponseValue = wasm.TS_Bolt11Invoice_to_str(o);
50033 return nativeResponseValue;
50035 // struct LDKStr SignedRawBolt11Invoice_to_str(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
50037 export function SignedRawBolt11Invoice_to_str(o: bigint): number {
50038 if(!isWasmInitialized) {
50039 throw new Error("initializeWasm() must be awaited first!");
50041 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_to_str(o);
50042 return nativeResponseValue;
50044 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
50046 export function Currency_to_str(o: bigint): number {
50047 if(!isWasmInitialized) {
50048 throw new Error("initializeWasm() must be awaited first!");
50050 const nativeResponseValue = wasm.TS_Currency_to_str(o);
50051 return nativeResponseValue;
50053 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
50055 export function SiPrefix_to_str(o: bigint): number {
50056 if(!isWasmInitialized) {
50057 throw new Error("initializeWasm() must be awaited first!");
50059 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
50060 return nativeResponseValue;
50064 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) {
50065 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
50066 if (weak == null || weak == undefined) {
50067 console.error("Got function call on unknown/free'd JS object!");
50068 throw new Error("Got function call on unknown/free'd JS object!");
50070 const obj = weak.deref();
50071 if (obj == null || obj == undefined) {
50072 console.error("Got function call on GC'd JS object!");
50073 throw new Error("Got function call on GC'd JS object!");
50077 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
50078 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
50079 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
50080 case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
50081 case 4: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
50082 case 5: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
50083 case 6: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
50084 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
50085 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
50086 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
50087 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_htlc_transaction"); break;
50088 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
50089 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
50090 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
50091 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
50092 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
50093 case 16: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
50094 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
50095 case 18: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
50096 case 19: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
50097 case 20: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
50098 case 21: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transactions"); break;
50099 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
50100 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
50101 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
50102 case 25: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
50103 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
50104 case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
50105 case 28: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
50106 case 29: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
50107 case 30: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
50108 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
50109 case 32: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
50110 case 33: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
50111 case 34: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
50112 case 35: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
50113 case 36: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
50114 case 37: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
50115 case 38: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
50116 case 39: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
50117 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
50118 case 41: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
50119 case 42: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
50120 case 43: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
50121 case 44: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
50122 case 45: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
50123 case 46: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
50124 case 47: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
50125 case 48: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
50126 case 49: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
50127 case 50: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
50128 case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
50129 case 52: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
50130 case 53: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
50131 case 54: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
50132 case 55: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
50133 case 56: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
50134 case 57: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
50135 case 58: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
50136 case 59: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
50137 case 60: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
50138 case 61: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
50139 case 62: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
50140 case 63: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
50141 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
50142 case 65: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
50143 case 66: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
50144 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
50145 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel_v2"); break;
50146 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
50147 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel_v2"); break;
50148 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
50149 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
50150 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
50151 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
50152 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
50153 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_input"); break;
50154 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_output"); break;
50155 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_input"); break;
50156 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_output"); break;
50157 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_complete"); break;
50158 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_signatures"); break;
50159 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_init_rbf"); break;
50160 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_ack_rbf"); break;
50161 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_abort"); break;
50162 case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
50163 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
50164 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
50165 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
50166 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
50167 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
50168 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
50169 case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
50170 case 93: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
50171 case 94: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
50172 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
50173 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
50174 case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
50175 case 98: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
50176 case 99: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
50177 case 100: fn = Object.getOwnPropertyDescriptor(obj, "get_genesis_hashes"); break;
50178 case 101: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
50179 case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
50180 case 103: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
50181 case 104: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
50182 case 105: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
50183 case 106: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
50184 case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
50185 case 108: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
50186 case 109: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
50187 case 110: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
50188 case 111: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
50189 case 112: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
50190 case 113: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
50191 case 114: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
50192 case 115: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
50193 case 116: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
50194 case 117: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
50195 case 118: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
50196 case 119: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
50197 case 120: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
50198 case 121: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
50199 case 122: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
50200 case 123: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
50201 case 124: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
50202 case 125: fn = Object.getOwnPropertyDescriptor(obj, "handle_message"); break;
50203 case 126: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
50204 case 127: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
50205 case 128: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
50206 case 129: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
50207 case 130: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
50208 case 131: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
50209 case 132: fn = Object.getOwnPropertyDescriptor(obj, "find_path"); break;
50210 case 133: fn = Object.getOwnPropertyDescriptor(obj, "select_confirmed_utxos"); break;
50211 case 134: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
50212 case 135: fn = Object.getOwnPropertyDescriptor(obj, "list_confirmed_utxos"); break;
50213 case 136: fn = Object.getOwnPropertyDescriptor(obj, "get_change_script"); break;
50214 case 137: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
50216 console.error("Got unknown function call with id " + fn_id + " from C!");
50217 throw new Error("Got unknown function call with id " + fn_id + " from C!");
50219 if (fn == null || fn == undefined) {
50220 console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
50221 throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
50225 ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
50227 console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
50231 if (ret === undefined || ret === null) return BigInt(0);
50232 return BigInt(ret);