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 * These are generally used as the return value for an implementation of [`Persist`] which is used
481 * as the storage layer for a [`ChainMonitor`]. See the docs on [`Persist`] for a high-level
482 * explanation of how to handle different cases.
484 * While `UnrecoverableError` is provided as a failure variant, it is not truly \"handled\" on the
485 * calling side, and generally results in an immediate panic. For those who prefer to avoid
486 * panics, `InProgress` can be used and you can retry the update operation in the background or
489 * Note that channels should generally *not* be force-closed after a persistence failure.
490 * Force-closing with the latest [`ChannelMonitorUpdate`] applied may result in a transaction
491 * being broadcast which can only be spent by the latest [`ChannelMonitor`]! Thus, if the
492 * latest [`ChannelMonitor`] is not durably persisted anywhere and exists only in memory, naively
493 * calling [`ChannelManager::force_close_broadcasting_latest_txn`] *may result in loss of funds*!
495 * [`Persist`]: chainmonitor::Persist
496 * [`ChainMonitor`]: chainmonitor::ChainMonitor
497 * [`ChannelManager::force_close_broadcasting_latest_txn`]: crate::ln::channelmanager::ChannelManager::force_close_broadcasting_latest_txn
499 export enum ChannelMonitorUpdateStatus {
501 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
504 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
505 be available on restart even if the application crashes.
507 LDKChannelMonitorUpdateStatus_Completed,
509 * Indicates that the update will happen asynchronously in the background or that a transient
510 failure occurred which is being retried in the background and will eventually complete.
512 This will \"freeze\" a channel, preventing us from revoking old states or submitting a new
513 commitment transaction to the counterparty. Once the update(s) which are `InProgress` have
514 been completed, a [`MonitorEvent::Completed`] can be used to restore the channel to an
517 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
518 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
519 attempting to claim it on this channel) and those updates must still be persisted.
521 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
522 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
523 monitor update for the same channel.
525 For deployments where a copy of [`ChannelMonitor`]s and other local state are backed up in
526 a remote location (with local copies persisted immediately), it is anticipated that all
527 updates will return [`InProgress`] until the remote copies could be updated.
529 Note that while fully asynchronous persistence of [`ChannelMonitor`] data is generally
530 reliable, this feature is considered beta, and a handful of edge-cases remain. Until the
531 remaining cases are fixed, in rare cases, *using this feature may lead to funds loss*.
533 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
535 LDKChannelMonitorUpdateStatus_InProgress,
537 * Indicates that an update has failed and will not complete at any point in the future.
539 Currently returning this variant will cause LDK to immediately panic to encourage immediate
540 shutdown. In the future this may be updated to disconnect peers and refuse to continue
541 normal operation without a panic.
543 Applications which wish to perform an orderly shutdown after failure should consider
544 returning [`InProgress`] instead and simply shut down without ever marking the update
547 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
549 LDKChannelMonitorUpdateStatus_UnrecoverableError,
554 * Further information on the details of the channel shutdown.
555 * Upon channels being forced closed (i.e. commitment transaction confirmation detected
556 * by `ChainMonitor`), ChannelShutdownState will be set to `ShutdownComplete` or
557 * the channel will be removed shortly.
558 * Also note, that in normal operation, peers could disconnect at any of these states
559 * and require peer re-connection before making progress onto other states
561 export enum ChannelShutdownState {
563 * Channel has not sent or received a shutdown message.
565 LDKChannelShutdownState_NotShuttingDown,
567 * Local node has sent a shutdown message for this channel.
569 LDKChannelShutdownState_ShutdownInitiated,
571 * Shutdown message exchanges have concluded and the channels are in the midst of
572 resolving all existing open HTLCs before closing can continue.
574 LDKChannelShutdownState_ResolvingHTLCs,
576 * All HTLCs have been resolved, nodes are currently negotiating channel close onchain fee rates.
578 LDKChannelShutdownState_NegotiatingClosingFee,
580 * We've successfully negotiated a closing_signed dance. At this point `ChannelManager` is about
583 LDKChannelShutdownState_ShutdownComplete,
588 * An enum that represents the priority at which we want a transaction to confirm used for feerate
591 export enum ConfirmationTarget {
593 * We'd like a transaction to confirm in the future, but don't want to commit most of the fees
594 required to do so yet. The remaining fees will come via a Child-Pays-For-Parent (CPFP) fee
595 bump of the transaction.
597 The feerate returned should be the absolute minimum feerate required to enter most node
598 mempools across the network. Note that if you are not able to obtain this feerate estimate,
599 you should likely use the furthest-out estimate allowed by your fee estimator.
601 LDKConfirmationTarget_MempoolMinimum,
603 * We are happy with a transaction confirming slowly, at least within a day or so worth of
606 LDKConfirmationTarget_Background,
608 * We'd like a transaction to confirm without major delayed, i.e., within the next 12-24 blocks.
610 LDKConfirmationTarget_Normal,
612 * We'd like a transaction to confirm in the next few blocks.
614 LDKConfirmationTarget_HighPriority,
619 * Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
621 export enum CreationError {
623 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
625 LDKCreationError_DescriptionTooLong,
627 * The specified route has too many hops and can't be encoded
629 LDKCreationError_RouteTooLong,
631 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
633 LDKCreationError_TimestampOutOfBounds,
635 * The supplied millisatoshi amount was greater than the total bitcoin supply.
637 LDKCreationError_InvalidAmount,
639 * Route hints were required for this invoice and were missing. Applies to
642 [phantom invoices]: crate::utils::create_phantom_invoice
644 LDKCreationError_MissingRouteHints,
646 * The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
648 [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
650 LDKCreationError_MinFinalCltvExpiryDeltaTooShort,
655 * Enum representing the crypto currencies (or networks) supported by this library
657 export enum Currency {
665 LDKCurrency_BitcoinTestnet,
682 * Describes the type of HTLC claim as determined by analyzing the witness.
684 export enum HTLCClaim {
686 * Claims an offered output on a commitment transaction through the timeout path.
688 LDKHTLCClaim_OfferedTimeout,
690 * Claims an offered output on a commitment transaction through the success path.
692 LDKHTLCClaim_OfferedPreimage,
694 * Claims an accepted output on a commitment transaction through the timeout path.
696 LDKHTLCClaim_AcceptedTimeout,
698 * Claims an accepted output on a commitment transaction through the success path.
700 LDKHTLCClaim_AcceptedPreimage,
702 * Claims an offered/accepted output on a commitment transaction through the revocation path.
704 LDKHTLCClaim_Revocation,
709 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
711 export enum IOError {
713 LDKIOError_PermissionDenied,
714 LDKIOError_ConnectionRefused,
715 LDKIOError_ConnectionReset,
716 LDKIOError_ConnectionAborted,
717 LDKIOError_NotConnected,
718 LDKIOError_AddrInUse,
719 LDKIOError_AddrNotAvailable,
720 LDKIOError_BrokenPipe,
721 LDKIOError_AlreadyExists,
722 LDKIOError_WouldBlock,
723 LDKIOError_InvalidInput,
724 LDKIOError_InvalidData,
726 LDKIOError_WriteZero,
727 LDKIOError_Interrupted,
729 LDKIOError_UnexpectedEof,
734 * An enum representing the available verbosity levels of the logger.
738 * Designates extremely verbose information, including gossip-induced messages
742 * Designates very low priority, often extremely verbose, information
746 * Designates lower priority information
750 * Designates useful information
754 * Designates hazardous situations
758 * Designates very serious errors
765 * An enum representing the possible Bitcoin or test networks which we can run on
767 export enum Network {
769 * The main Bitcoin blockchain.
773 * The testnet3 blockchain.
777 * A local test blockchain.
781 * A blockchain on which blocks are signed instead of mined.
788 * The reason the payment failed. Used in [`Event::PaymentFailed`].
790 export enum PaymentFailureReason {
792 * The intended recipient rejected our payment.
794 LDKPaymentFailureReason_RecipientRejected,
796 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
798 [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
800 LDKPaymentFailureReason_UserAbandoned,
802 * We exhausted all of our retry attempts while trying to send the payment, or we
803 exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
804 attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
805 have come before this.
807 [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
809 LDKPaymentFailureReason_RetriesExhausted,
811 * The payment expired while retrying, based on the provided
812 [`PaymentParameters::expiry_time`].
814 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
816 LDKPaymentFailureReason_PaymentExpired,
818 * We failed to find a route while retrying the payment.
820 LDKPaymentFailureReason_RouteNotFound,
822 * This error should generally never happen. This likely means that there is a problem with
825 LDKPaymentFailureReason_UnexpectedError,
830 * Specifies the recipient of an invoice.
832 * This indicates to [`NodeSigner::sign_invoice`] what node secret key should be used to sign
835 export enum Recipient {
837 * The invoice should be signed with the local node secret key.
841 * The invoice should be signed with the phantom node secret key. This secret key must be the
842 same for all nodes participating in the [phantom node payment].
844 [phantom node payment]: PhantomKeysManager
846 LDKRecipient_PhantomNode,
851 * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
852 * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
854 * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
855 * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
856 * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
858 export enum RetryableSendFailure {
860 * The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
861 that this error is *not* caused by [`Retry::Timeout`].
863 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
865 LDKRetryableSendFailure_PaymentExpired,
867 * We were unable to find a route to the destination.
869 LDKRetryableSendFailure_RouteNotFound,
871 * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
872 yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
874 [`PaymentId`]: crate::ln::channelmanager::PaymentId
875 [`Event::PaymentSent`]: crate::events::Event::PaymentSent
876 [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
878 LDKRetryableSendFailure_DuplicatePayment,
883 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
885 export enum Secp256k1Error {
887 * Signature failed verification
889 LDKSecp256k1Error_IncorrectSignature,
891 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
893 LDKSecp256k1Error_InvalidMessage,
897 LDKSecp256k1Error_InvalidPublicKey,
901 LDKSecp256k1Error_InvalidSignature,
905 LDKSecp256k1Error_InvalidSecretKey,
909 LDKSecp256k1Error_InvalidSharedSecret,
913 LDKSecp256k1Error_InvalidRecoveryId,
915 * Invalid tweak for add_assign or mul_assign
917 LDKSecp256k1Error_InvalidTweak,
919 * Didn't pass enough memory to context creation with preallocated memory
921 LDKSecp256k1Error_NotEnoughMemory,
923 * Bad set of public keys.
925 LDKSecp256k1Error_InvalidPublicKeySum,
927 * The only valid parity values are 0 or 1.
929 LDKSecp256k1Error_InvalidParityValue,
934 * SI prefixes for the human readable part
936 export enum SiPrefix {
957 * [`SocketAddress`] error variants
959 export enum SocketAddressParseError {
961 * Socket address (IPv4/IPv6) parsing error
963 LDKSocketAddressParseError_SocketAddrParse,
965 * Invalid input format
967 LDKSocketAddressParseError_InvalidInput,
971 LDKSocketAddressParseError_InvalidPort,
973 * Invalid onion v3 address
975 LDKSocketAddressParseError_InvalidOnionV3,
980 * An error when accessing the chain via [`UtxoLookup`].
982 export enum UtxoLookupError {
984 * The requested chain is unknown.
986 LDKUtxoLookupError_UnknownChain,
988 * The requested transaction doesn't exist or hasn't confirmed.
990 LDKUtxoLookupError_UnknownTx,
993 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
995 export function BigEndianScalar_get_bytes(thing: bigint): number {
996 if(!isWasmInitialized) {
997 throw new Error("initializeWasm() must be awaited first!");
999 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
1000 return nativeResponseValue;
1002 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
1004 export function BigEndianScalar_free(thing: bigint): void {
1005 if(!isWasmInitialized) {
1006 throw new Error("initializeWasm() must be awaited first!");
1008 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
1009 // debug statements here
1012 export class LDKBech32Error {
1013 protected constructor() {}
1016 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
1017 if(!isWasmInitialized) {
1018 throw new Error("initializeWasm() must be awaited first!");
1020 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
1021 return nativeResponseValue;
1024 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
1025 if(!isWasmInitialized) {
1026 throw new Error("initializeWasm() must be awaited first!");
1028 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
1029 return nativeResponseValue;
1032 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
1033 if(!isWasmInitialized) {
1034 throw new Error("initializeWasm() must be awaited first!");
1036 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
1037 return nativeResponseValue;
1039 // struct LDKWitness TxIn_get_witness (struct LDKTxIn* thing)
1041 export function TxIn_get_witness(thing: bigint): number {
1042 if(!isWasmInitialized) {
1043 throw new Error("initializeWasm() must be awaited first!");
1045 const nativeResponseValue = wasm.TS_TxIn_get_witness(thing);
1046 return nativeResponseValue;
1048 // struct LDKCVec_u8Z TxIn_get_script_sig (struct LDKTxIn* thing)
1050 export function TxIn_get_script_sig(thing: bigint): number {
1051 if(!isWasmInitialized) {
1052 throw new Error("initializeWasm() must be awaited first!");
1054 const nativeResponseValue = wasm.TS_TxIn_get_script_sig(thing);
1055 return nativeResponseValue;
1057 // LDKThirtyTwoBytes TxIn_get_previous_txid (struct LDKTxIn* thing)
1059 export function TxIn_get_previous_txid(thing: bigint): number {
1060 if(!isWasmInitialized) {
1061 throw new Error("initializeWasm() must be awaited first!");
1063 const nativeResponseValue = wasm.TS_TxIn_get_previous_txid(thing);
1064 return nativeResponseValue;
1066 // uint32_t TxIn_get_previous_vout (struct LDKTxIn* thing)
1068 export function TxIn_get_previous_vout(thing: bigint): number {
1069 if(!isWasmInitialized) {
1070 throw new Error("initializeWasm() must be awaited first!");
1072 const nativeResponseValue = wasm.TS_TxIn_get_previous_vout(thing);
1073 return nativeResponseValue;
1075 // uint32_t TxIn_get_sequence (struct LDKTxIn* thing)
1077 export function TxIn_get_sequence(thing: bigint): number {
1078 if(!isWasmInitialized) {
1079 throw new Error("initializeWasm() must be awaited first!");
1081 const nativeResponseValue = wasm.TS_TxIn_get_sequence(thing);
1082 return nativeResponseValue;
1084 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
1086 export function TxOut_get_script_pubkey(thing: bigint): number {
1087 if(!isWasmInitialized) {
1088 throw new Error("initializeWasm() must be awaited first!");
1090 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
1091 return nativeResponseValue;
1093 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
1095 export function TxOut_get_value(thing: bigint): bigint {
1096 if(!isWasmInitialized) {
1097 throw new Error("initializeWasm() must be awaited first!");
1099 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
1100 return nativeResponseValue;
1103 export class LDKCOption_u64Z {
1104 protected constructor() {}
1107 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1108 if(!isWasmInitialized) {
1109 throw new Error("initializeWasm() must be awaited first!");
1111 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1112 return nativeResponseValue;
1115 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1116 if(!isWasmInitialized) {
1117 throw new Error("initializeWasm() must be awaited first!");
1119 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1120 return nativeResponseValue;
1122 // struct LDKRefund CResult_RefundBolt12ParseErrorZ_get_ok(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1124 export function CResult_RefundBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
1125 if(!isWasmInitialized) {
1126 throw new Error("initializeWasm() must be awaited first!");
1128 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_ok(owner);
1129 return nativeResponseValue;
1131 // struct LDKBolt12ParseError CResult_RefundBolt12ParseErrorZ_get_err(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1133 export function CResult_RefundBolt12ParseErrorZ_get_err(owner: bigint): bigint {
1134 if(!isWasmInitialized) {
1135 throw new Error("initializeWasm() must be awaited first!");
1137 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_err(owner);
1138 return nativeResponseValue;
1141 export class LDKRetry {
1142 protected constructor() {}
1145 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
1146 if(!isWasmInitialized) {
1147 throw new Error("initializeWasm() must be awaited first!");
1149 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
1150 return nativeResponseValue;
1153 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
1154 if(!isWasmInitialized) {
1155 throw new Error("initializeWasm() must be awaited first!");
1157 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
1158 return nativeResponseValue;
1161 export class LDKDecodeError {
1162 protected constructor() {}
1165 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
1166 if(!isWasmInitialized) {
1167 throw new Error("initializeWasm() must be awaited first!");
1169 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
1170 return nativeResponseValue;
1173 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
1174 if(!isWasmInitialized) {
1175 throw new Error("initializeWasm() must be awaited first!");
1177 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
1178 return nativeResponseValue;
1180 // struct LDKRetry CResult_RetryDecodeErrorZ_get_ok(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1182 export function CResult_RetryDecodeErrorZ_get_ok(owner: bigint): bigint {
1183 if(!isWasmInitialized) {
1184 throw new Error("initializeWasm() must be awaited first!");
1186 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_ok(owner);
1187 return nativeResponseValue;
1189 // struct LDKDecodeError CResult_RetryDecodeErrorZ_get_err(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1191 export function CResult_RetryDecodeErrorZ_get_err(owner: bigint): bigint {
1192 if(!isWasmInitialized) {
1193 throw new Error("initializeWasm() must be awaited first!");
1195 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_err(owner);
1196 return nativeResponseValue;
1199 export class LDKAPIError {
1200 protected constructor() {}
1203 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
1204 if(!isWasmInitialized) {
1205 throw new Error("initializeWasm() must be awaited first!");
1207 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
1208 return nativeResponseValue;
1211 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
1212 if(!isWasmInitialized) {
1213 throw new Error("initializeWasm() must be awaited first!");
1215 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
1216 return nativeResponseValue;
1219 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
1220 if(!isWasmInitialized) {
1221 throw new Error("initializeWasm() must be awaited first!");
1223 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
1224 return nativeResponseValue;
1227 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
1228 if(!isWasmInitialized) {
1229 throw new Error("initializeWasm() must be awaited first!");
1231 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
1232 return nativeResponseValue;
1235 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
1236 if(!isWasmInitialized) {
1237 throw new Error("initializeWasm() must be awaited first!");
1239 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
1240 return nativeResponseValue;
1243 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
1244 if(!isWasmInitialized) {
1245 throw new Error("initializeWasm() must be awaited first!");
1247 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
1248 return nativeResponseValue;
1251 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
1252 if(!isWasmInitialized) {
1253 throw new Error("initializeWasm() must be awaited first!");
1255 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
1256 return nativeResponseValue;
1258 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1260 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
1261 if(!isWasmInitialized) {
1262 throw new Error("initializeWasm() must be awaited first!");
1264 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
1265 // debug statements here
1267 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1269 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
1270 if(!isWasmInitialized) {
1271 throw new Error("initializeWasm() must be awaited first!");
1273 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
1274 return nativeResponseValue;
1277 export class LDKCOption_ThirtyTwoBytesZ {
1278 protected constructor() {}
1281 export function LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr: bigint): number {
1282 if(!isWasmInitialized) {
1283 throw new Error("initializeWasm() must be awaited first!");
1285 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr);
1286 return nativeResponseValue;
1289 export function LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr: bigint): number {
1290 if(!isWasmInitialized) {
1291 throw new Error("initializeWasm() must be awaited first!");
1293 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr);
1294 return nativeResponseValue;
1297 export class LDKCOption_CVec_u8ZZ {
1298 protected constructor() {}
1301 export function LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr: bigint): number {
1302 if(!isWasmInitialized) {
1303 throw new Error("initializeWasm() must be awaited first!");
1305 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr);
1306 return nativeResponseValue;
1309 export function LDKCOption_CVec_u8ZZ_Some_get_some(ptr: bigint): number {
1310 if(!isWasmInitialized) {
1311 throw new Error("initializeWasm() must be awaited first!");
1313 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_Some_get_some(ptr);
1314 return nativeResponseValue;
1316 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1318 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
1319 if(!isWasmInitialized) {
1320 throw new Error("initializeWasm() must be awaited first!");
1322 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner);
1323 return nativeResponseValue;
1325 // struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1327 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
1328 if(!isWasmInitialized) {
1329 throw new Error("initializeWasm() must be awaited first!");
1331 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner);
1332 return nativeResponseValue;
1334 // uint64_t C2Tuple_u64CVec_u8ZZ_get_a(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1336 export function C2Tuple_u64CVec_u8ZZ_get_a(owner: bigint): bigint {
1337 if(!isWasmInitialized) {
1338 throw new Error("initializeWasm() must be awaited first!");
1340 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_a(owner);
1341 return nativeResponseValue;
1343 // struct LDKCVec_u8Z C2Tuple_u64CVec_u8ZZ_get_b(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1345 export function C2Tuple_u64CVec_u8ZZ_get_b(owner: bigint): number {
1346 if(!isWasmInitialized) {
1347 throw new Error("initializeWasm() must be awaited first!");
1349 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_b(owner);
1350 return nativeResponseValue;
1352 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsNoneZ_get_ok(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1354 export function CResult_RecipientOnionFieldsNoneZ_get_ok(owner: bigint): bigint {
1355 if(!isWasmInitialized) {
1356 throw new Error("initializeWasm() must be awaited first!");
1358 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_ok(owner);
1359 return nativeResponseValue;
1361 // void CResult_RecipientOnionFieldsNoneZ_get_err(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1363 export function CResult_RecipientOnionFieldsNoneZ_get_err(owner: bigint): void {
1364 if(!isWasmInitialized) {
1365 throw new Error("initializeWasm() must be awaited first!");
1367 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_err(owner);
1368 // debug statements here
1371 export class LDKCOption_CVec_ThirtyTwoBytesZZ {
1372 protected constructor() {}
1375 export function LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr: bigint): number {
1376 if(!isWasmInitialized) {
1377 throw new Error("initializeWasm() must be awaited first!");
1379 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr);
1380 return nativeResponseValue;
1383 export function LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr: bigint): number {
1384 if(!isWasmInitialized) {
1385 throw new Error("initializeWasm() must be awaited first!");
1387 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr);
1388 return nativeResponseValue;
1390 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesNoneZ_get_ok(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1392 export function CResult_ThirtyTwoBytesNoneZ_get_ok(owner: bigint): number {
1393 if(!isWasmInitialized) {
1394 throw new Error("initializeWasm() must be awaited first!");
1396 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_ok(owner);
1397 return nativeResponseValue;
1399 // void CResult_ThirtyTwoBytesNoneZ_get_err(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1401 export function CResult_ThirtyTwoBytesNoneZ_get_err(owner: bigint): void {
1402 if(!isWasmInitialized) {
1403 throw new Error("initializeWasm() must be awaited first!");
1405 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_err(owner);
1406 // debug statements here
1408 // struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1410 export function CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
1411 if(!isWasmInitialized) {
1412 throw new Error("initializeWasm() must be awaited first!");
1414 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner);
1415 return nativeResponseValue;
1417 // struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1419 export function CResult_BlindedPayInfoDecodeErrorZ_get_err(owner: bigint): bigint {
1420 if(!isWasmInitialized) {
1421 throw new Error("initializeWasm() must be awaited first!");
1423 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(owner);
1424 return nativeResponseValue;
1426 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1428 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1429 if(!isWasmInitialized) {
1430 throw new Error("initializeWasm() must be awaited first!");
1432 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1433 return nativeResponseValue;
1435 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1437 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1438 if(!isWasmInitialized) {
1439 throw new Error("initializeWasm() must be awaited first!");
1441 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1442 return nativeResponseValue;
1444 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1446 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1447 if(!isWasmInitialized) {
1448 throw new Error("initializeWasm() must be awaited first!");
1450 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1451 return nativeResponseValue;
1453 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1455 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1456 if(!isWasmInitialized) {
1457 throw new Error("initializeWasm() must be awaited first!");
1459 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1460 return nativeResponseValue;
1463 export class LDKSpendableOutputDescriptor {
1464 protected constructor() {}
1467 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1468 if(!isWasmInitialized) {
1469 throw new Error("initializeWasm() must be awaited first!");
1471 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1472 return nativeResponseValue;
1475 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1476 if(!isWasmInitialized) {
1477 throw new Error("initializeWasm() must be awaited first!");
1479 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1480 return nativeResponseValue;
1483 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1484 if(!isWasmInitialized) {
1485 throw new Error("initializeWasm() must be awaited first!");
1487 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1488 return nativeResponseValue;
1491 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1492 if(!isWasmInitialized) {
1493 throw new Error("initializeWasm() must be awaited first!");
1495 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1496 return nativeResponseValue;
1499 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1500 if(!isWasmInitialized) {
1501 throw new Error("initializeWasm() must be awaited first!");
1503 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1504 return nativeResponseValue;
1506 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1508 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1509 if(!isWasmInitialized) {
1510 throw new Error("initializeWasm() must be awaited first!");
1512 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
1513 return nativeResponseValue;
1515 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1517 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1518 if(!isWasmInitialized) {
1519 throw new Error("initializeWasm() must be awaited first!");
1521 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
1522 return nativeResponseValue;
1525 export class LDKCOption_u32Z {
1526 protected constructor() {}
1529 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
1530 if(!isWasmInitialized) {
1531 throw new Error("initializeWasm() must be awaited first!");
1533 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
1534 return nativeResponseValue;
1537 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
1538 if(!isWasmInitialized) {
1539 throw new Error("initializeWasm() must be awaited first!");
1541 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
1542 return nativeResponseValue;
1544 // struct LDKCVec_u8Z C2Tuple_CVec_u8ZusizeZ_get_a(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR owner);
1546 export function C2Tuple_CVec_u8ZusizeZ_get_a(owner: bigint): number {
1547 if(!isWasmInitialized) {
1548 throw new Error("initializeWasm() must be awaited first!");
1550 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_get_a(owner);
1551 return nativeResponseValue;
1553 // uintptr_t C2Tuple_CVec_u8ZusizeZ_get_b(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR owner);
1555 export function C2Tuple_CVec_u8ZusizeZ_get_b(owner: bigint): number {
1556 if(!isWasmInitialized) {
1557 throw new Error("initializeWasm() must be awaited first!");
1559 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_get_b(owner);
1560 return nativeResponseValue;
1562 // struct LDKC2Tuple_CVec_u8ZusizeZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR owner);
1564 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(owner: bigint): bigint {
1565 if(!isWasmInitialized) {
1566 throw new Error("initializeWasm() must be awaited first!");
1568 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(owner);
1569 return nativeResponseValue;
1571 // void CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR owner);
1573 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(owner: bigint): void {
1574 if(!isWasmInitialized) {
1575 throw new Error("initializeWasm() must be awaited first!");
1577 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(owner);
1578 // debug statements here
1580 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1582 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
1583 if(!isWasmInitialized) {
1584 throw new Error("initializeWasm() must be awaited first!");
1586 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
1587 // debug statements here
1589 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1591 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
1592 if(!isWasmInitialized) {
1593 throw new Error("initializeWasm() must be awaited first!");
1595 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
1596 // debug statements here
1598 // struct LDKECDSASignature C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
1600 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner: bigint): number {
1601 if(!isWasmInitialized) {
1602 throw new Error("initializeWasm() must be awaited first!");
1604 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner);
1605 return nativeResponseValue;
1607 // struct LDKCVec_ECDSASignatureZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
1609 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner: bigint): number {
1610 if(!isWasmInitialized) {
1611 throw new Error("initializeWasm() must be awaited first!");
1613 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner);
1614 return nativeResponseValue;
1616 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
1618 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner: bigint): bigint {
1619 if(!isWasmInitialized) {
1620 throw new Error("initializeWasm() must be awaited first!");
1622 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner);
1623 return nativeResponseValue;
1625 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
1627 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner: bigint): void {
1628 if(!isWasmInitialized) {
1629 throw new Error("initializeWasm() must be awaited first!");
1631 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner);
1632 // debug statements here
1634 // struct LDKECDSASignature CResult_ECDSASignatureNoneZ_get_ok(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1636 export function CResult_ECDSASignatureNoneZ_get_ok(owner: bigint): number {
1637 if(!isWasmInitialized) {
1638 throw new Error("initializeWasm() must be awaited first!");
1640 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_ok(owner);
1641 return nativeResponseValue;
1643 // void CResult_ECDSASignatureNoneZ_get_err(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1645 export function CResult_ECDSASignatureNoneZ_get_err(owner: bigint): void {
1646 if(!isWasmInitialized) {
1647 throw new Error("initializeWasm() must be awaited first!");
1649 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_err(owner);
1650 // debug statements here
1652 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1654 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
1655 if(!isWasmInitialized) {
1656 throw new Error("initializeWasm() must be awaited first!");
1658 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
1659 return nativeResponseValue;
1661 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1663 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
1664 if(!isWasmInitialized) {
1665 throw new Error("initializeWasm() must be awaited first!");
1667 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
1668 // debug statements here
1671 export class LDKCOption_BigEndianScalarZ {
1672 protected constructor() {}
1675 export function LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr: bigint): number {
1676 if(!isWasmInitialized) {
1677 throw new Error("initializeWasm() must be awaited first!");
1679 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr);
1680 return nativeResponseValue;
1683 export function LDKCOption_BigEndianScalarZ_Some_get_some(ptr: bigint): bigint {
1684 if(!isWasmInitialized) {
1685 throw new Error("initializeWasm() must be awaited first!");
1687 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_Some_get_some(ptr);
1688 return nativeResponseValue;
1690 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1692 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
1693 if(!isWasmInitialized) {
1694 throw new Error("initializeWasm() must be awaited first!");
1696 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
1697 return nativeResponseValue;
1699 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1701 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
1702 if(!isWasmInitialized) {
1703 throw new Error("initializeWasm() must be awaited first!");
1705 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
1706 // debug statements here
1708 // struct LDKSchnorrSignature CResult_SchnorrSignatureNoneZ_get_ok(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1710 export function CResult_SchnorrSignatureNoneZ_get_ok(owner: bigint): number {
1711 if(!isWasmInitialized) {
1712 throw new Error("initializeWasm() must be awaited first!");
1714 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_ok(owner);
1715 return nativeResponseValue;
1717 // void CResult_SchnorrSignatureNoneZ_get_err(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1719 export function CResult_SchnorrSignatureNoneZ_get_err(owner: bigint): void {
1720 if(!isWasmInitialized) {
1721 throw new Error("initializeWasm() must be awaited first!");
1723 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_err(owner);
1724 // debug statements here
1727 export interface LDKChannelSigner {
1728 get_per_commitment_point (idx: bigint): number;
1729 release_commitment_secret (idx: bigint): number;
1730 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
1731 channel_keys_id (): number;
1732 provide_channel_parameters (channel_parameters: bigint): void;
1736 export function LDKChannelSigner_new(impl: LDKChannelSigner, pubkeys: bigint): [bigint, number] {
1737 if(!isWasmInitialized) {
1738 throw new Error("initializeWasm() must be awaited first!");
1740 var new_obj_idx = js_objs.length;
1741 for (var i = 0; i < js_objs.length; i++) {
1742 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1744 js_objs[i] = new WeakRef(impl);
1745 return [wasm.TS_LDKChannelSigner_new(i, pubkeys), i];
1747 // LDKPublicKey ChannelSigner_get_per_commitment_point LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
1749 export function ChannelSigner_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
1750 if(!isWasmInitialized) {
1751 throw new Error("initializeWasm() must be awaited first!");
1753 const nativeResponseValue = wasm.TS_ChannelSigner_get_per_commitment_point(this_arg, idx);
1754 return nativeResponseValue;
1756 // LDKThirtyTwoBytes ChannelSigner_release_commitment_secret LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
1758 export function ChannelSigner_release_commitment_secret(this_arg: bigint, idx: bigint): number {
1759 if(!isWasmInitialized) {
1760 throw new Error("initializeWasm() must be awaited first!");
1762 const nativeResponseValue = wasm.TS_ChannelSigner_release_commitment_secret(this_arg, idx);
1763 return nativeResponseValue;
1765 // LDKCResult_NoneNoneZ ChannelSigner_validate_holder_commitment LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages
1767 export function ChannelSigner_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
1768 if(!isWasmInitialized) {
1769 throw new Error("initializeWasm() must be awaited first!");
1771 const nativeResponseValue = wasm.TS_ChannelSigner_validate_holder_commitment(this_arg, holder_tx, preimages);
1772 return nativeResponseValue;
1774 // LDKThirtyTwoBytes ChannelSigner_channel_keys_id LDKChannelSigner *NONNULL_PTR this_arg
1776 export function ChannelSigner_channel_keys_id(this_arg: bigint): number {
1777 if(!isWasmInitialized) {
1778 throw new Error("initializeWasm() must be awaited first!");
1780 const nativeResponseValue = wasm.TS_ChannelSigner_channel_keys_id(this_arg);
1781 return nativeResponseValue;
1783 // void ChannelSigner_provide_channel_parameters LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
1785 export function ChannelSigner_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
1786 if(!isWasmInitialized) {
1787 throw new Error("initializeWasm() must be awaited first!");
1789 const nativeResponseValue = wasm.TS_ChannelSigner_provide_channel_parameters(this_arg, channel_parameters);
1790 // debug statements here
1792 // LDKChannelPublicKeys ChannelSigner_get_pubkeys LDKChannelSigner *NONNULL_PTR this_arg
1794 export function ChannelSigner_get_pubkeys(this_arg: bigint): bigint {
1795 if(!isWasmInitialized) {
1796 throw new Error("initializeWasm() must be awaited first!");
1798 const nativeResponseValue = wasm.TS_ChannelSigner_get_pubkeys(this_arg);
1799 return nativeResponseValue;
1802 export interface LDKEcdsaChannelSigner {
1803 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
1804 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
1805 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
1806 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
1807 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
1808 sign_holder_htlc_transaction (htlc_tx: number, input: number, htlc_descriptor: bigint): bigint;
1809 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
1810 sign_closing_transaction (closing_tx: bigint): bigint;
1811 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
1812 sign_channel_announcement_with_funding_key (msg: bigint): bigint;
1816 export function LDKEcdsaChannelSigner_new(impl: LDKEcdsaChannelSigner, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
1817 if(!isWasmInitialized) {
1818 throw new Error("initializeWasm() must be awaited first!");
1820 var new_obj_idx = js_objs.length;
1821 for (var i = 0; i < js_objs.length; i++) {
1822 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1824 js_objs[i] = new WeakRef(impl);
1825 return [wasm.TS_LDKEcdsaChannelSigner_new(i, ChannelSigner, pubkeys), i];
1827 // LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner_sign_counterparty_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages
1829 export function EcdsaChannelSigner_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
1830 if(!isWasmInitialized) {
1831 throw new Error("initializeWasm() must be awaited first!");
1833 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
1834 return nativeResponseValue;
1836 // LDKCResult_NoneNoneZ EcdsaChannelSigner_validate_counterparty_revocation LDKEcdsaChannelSigner *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
1838 export function EcdsaChannelSigner_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
1839 if(!isWasmInitialized) {
1840 throw new Error("initializeWasm() must be awaited first!");
1842 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_validate_counterparty_revocation(this_arg, idx, secret);
1843 return nativeResponseValue;
1845 // LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner_sign_holder_commitment_and_htlcs LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
1847 export function EcdsaChannelSigner_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
1848 if(!isWasmInitialized) {
1849 throw new Error("initializeWasm() must be awaited first!");
1851 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
1852 return nativeResponseValue;
1854 // LDKCResult_ECDSASignatureNoneZ 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]
1856 export function EcdsaChannelSigner_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
1857 if(!isWasmInitialized) {
1858 throw new Error("initializeWasm() must be awaited first!");
1860 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
1861 return nativeResponseValue;
1863 // LDKCResult_ECDSASignatureNoneZ 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
1865 export function EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
1866 if(!isWasmInitialized) {
1867 throw new Error("initializeWasm() must be awaited first!");
1869 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
1870 return nativeResponseValue;
1872 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_htlc_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor
1874 export function EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, htlc_descriptor: bigint): bigint {
1875 if(!isWasmInitialized) {
1876 throw new Error("initializeWasm() must be awaited first!");
1878 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg, htlc_tx, input, htlc_descriptor);
1879 return nativeResponseValue;
1881 // LDKCResult_ECDSASignatureNoneZ 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
1883 export function EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
1884 if(!isWasmInitialized) {
1885 throw new Error("initializeWasm() must be awaited first!");
1887 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
1888 return nativeResponseValue;
1890 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_closing_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
1892 export function EcdsaChannelSigner_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
1893 if(!isWasmInitialized) {
1894 throw new Error("initializeWasm() must be awaited first!");
1896 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_closing_transaction(this_arg, closing_tx);
1897 return nativeResponseValue;
1899 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_anchor_input LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
1901 export function EcdsaChannelSigner_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
1902 if(!isWasmInitialized) {
1903 throw new Error("initializeWasm() must be awaited first!");
1905 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_anchor_input(this_arg, anchor_tx, input);
1906 return nativeResponseValue;
1908 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_channel_announcement_with_funding_key LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
1910 export function EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg: bigint, msg: bigint): bigint {
1911 if(!isWasmInitialized) {
1912 throw new Error("initializeWasm() must be awaited first!");
1914 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg, msg);
1915 return nativeResponseValue;
1918 export interface LDKWriteableEcdsaChannelSigner {
1923 export function LDKWriteableEcdsaChannelSigner_new(impl: LDKWriteableEcdsaChannelSigner, EcdsaChannelSigner: number, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
1924 if(!isWasmInitialized) {
1925 throw new Error("initializeWasm() must be awaited first!");
1927 var new_obj_idx = js_objs.length;
1928 for (var i = 0; i < js_objs.length; i++) {
1929 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1931 js_objs[i] = new WeakRef(impl);
1932 return [wasm.TS_LDKWriteableEcdsaChannelSigner_new(i, EcdsaChannelSigner, ChannelSigner, pubkeys), i];
1934 // LDKCVec_u8Z WriteableEcdsaChannelSigner_write LDKWriteableEcdsaChannelSigner *NONNULL_PTR this_arg
1936 export function WriteableEcdsaChannelSigner_write(this_arg: bigint): number {
1937 if(!isWasmInitialized) {
1938 throw new Error("initializeWasm() must be awaited first!");
1940 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_write(this_arg);
1941 return nativeResponseValue;
1943 // struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
1945 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner: bigint): bigint {
1946 if(!isWasmInitialized) {
1947 throw new Error("initializeWasm() must be awaited first!");
1949 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner);
1950 return nativeResponseValue;
1952 // struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
1954 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner: bigint): bigint {
1955 if(!isWasmInitialized) {
1956 throw new Error("initializeWasm() must be awaited first!");
1958 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner);
1959 return nativeResponseValue;
1961 // struct LDKCVec_u8Z CResult_CVec_u8ZNoneZ_get_ok(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
1963 export function CResult_CVec_u8ZNoneZ_get_ok(owner: bigint): number {
1964 if(!isWasmInitialized) {
1965 throw new Error("initializeWasm() must be awaited first!");
1967 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_ok(owner);
1968 return nativeResponseValue;
1970 // void CResult_CVec_u8ZNoneZ_get_err(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
1972 export function CResult_CVec_u8ZNoneZ_get_err(owner: bigint): void {
1973 if(!isWasmInitialized) {
1974 throw new Error("initializeWasm() must be awaited first!");
1976 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_err(owner);
1977 // debug statements here
1979 // struct LDKShutdownScript CResult_ShutdownScriptNoneZ_get_ok(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
1981 export function CResult_ShutdownScriptNoneZ_get_ok(owner: bigint): bigint {
1982 if(!isWasmInitialized) {
1983 throw new Error("initializeWasm() must be awaited first!");
1985 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_ok(owner);
1986 return nativeResponseValue;
1988 // void CResult_ShutdownScriptNoneZ_get_err(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
1990 export function CResult_ShutdownScriptNoneZ_get_err(owner: bigint): void {
1991 if(!isWasmInitialized) {
1992 throw new Error("initializeWasm() must be awaited first!");
1994 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_err(owner);
1995 // debug statements here
1998 export class LDKCOption_u16Z {
1999 protected constructor() {}
2002 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
2003 if(!isWasmInitialized) {
2004 throw new Error("initializeWasm() must be awaited first!");
2006 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2007 return nativeResponseValue;
2010 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
2011 if(!isWasmInitialized) {
2012 throw new Error("initializeWasm() must be awaited first!");
2014 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2015 return nativeResponseValue;
2018 export class LDKCOption_boolZ {
2019 protected constructor() {}
2022 export function LDKCOption_boolZ_ty_from_ptr(ptr: bigint): number {
2023 if(!isWasmInitialized) {
2024 throw new Error("initializeWasm() must be awaited first!");
2026 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_ty_from_ptr(ptr);
2027 return nativeResponseValue;
2030 export function LDKCOption_boolZ_Some_get_some(ptr: bigint): boolean {
2031 if(!isWasmInitialized) {
2032 throw new Error("initializeWasm() must be awaited first!");
2034 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_Some_get_some(ptr);
2035 return nativeResponseValue;
2037 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2039 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
2040 if(!isWasmInitialized) {
2041 throw new Error("initializeWasm() must be awaited first!");
2043 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
2044 return nativeResponseValue;
2046 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2048 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
2049 if(!isWasmInitialized) {
2050 throw new Error("initializeWasm() must be awaited first!");
2052 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
2053 // debug statements here
2055 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2057 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2058 if(!isWasmInitialized) {
2059 throw new Error("initializeWasm() must be awaited first!");
2061 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2062 return nativeResponseValue;
2064 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2066 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
2067 if(!isWasmInitialized) {
2068 throw new Error("initializeWasm() must be awaited first!");
2070 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2071 return nativeResponseValue;
2073 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2075 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
2076 if(!isWasmInitialized) {
2077 throw new Error("initializeWasm() must be awaited first!");
2079 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2080 return nativeResponseValue;
2082 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2084 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
2085 if(!isWasmInitialized) {
2086 throw new Error("initializeWasm() must be awaited first!");
2088 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2089 // debug statements here
2091 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2093 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
2094 if(!isWasmInitialized) {
2095 throw new Error("initializeWasm() must be awaited first!");
2097 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2098 return nativeResponseValue;
2100 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2102 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
2103 if(!isWasmInitialized) {
2104 throw new Error("initializeWasm() must be awaited first!");
2106 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2107 return nativeResponseValue;
2109 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2111 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
2112 if(!isWasmInitialized) {
2113 throw new Error("initializeWasm() must be awaited first!");
2115 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
2116 return nativeResponseValue;
2118 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2120 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
2121 if(!isWasmInitialized) {
2122 throw new Error("initializeWasm() must be awaited first!");
2124 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
2125 return nativeResponseValue;
2127 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2129 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2130 if(!isWasmInitialized) {
2131 throw new Error("initializeWasm() must be awaited first!");
2133 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
2134 return nativeResponseValue;
2136 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2138 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
2139 if(!isWasmInitialized) {
2140 throw new Error("initializeWasm() must be awaited first!");
2142 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
2143 return nativeResponseValue;
2145 // struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2147 export function CResult_BlindedTailDecodeErrorZ_get_ok(owner: bigint): bigint {
2148 if(!isWasmInitialized) {
2149 throw new Error("initializeWasm() must be awaited first!");
2151 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_ok(owner);
2152 return nativeResponseValue;
2154 // struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2156 export function CResult_BlindedTailDecodeErrorZ_get_err(owner: bigint): bigint {
2157 if(!isWasmInitialized) {
2158 throw new Error("initializeWasm() must be awaited first!");
2160 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_err(owner);
2161 return nativeResponseValue;
2163 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2165 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
2166 if(!isWasmInitialized) {
2167 throw new Error("initializeWasm() must be awaited first!");
2169 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
2170 return nativeResponseValue;
2172 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2174 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
2175 if(!isWasmInitialized) {
2176 throw new Error("initializeWasm() must be awaited first!");
2178 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
2179 return nativeResponseValue;
2181 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2183 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2184 if(!isWasmInitialized) {
2185 throw new Error("initializeWasm() must be awaited first!");
2187 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
2188 return nativeResponseValue;
2190 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2192 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2193 if(!isWasmInitialized) {
2194 throw new Error("initializeWasm() must be awaited first!");
2196 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
2197 return nativeResponseValue;
2199 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2201 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2202 if(!isWasmInitialized) {
2203 throw new Error("initializeWasm() must be awaited first!");
2205 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
2206 return nativeResponseValue;
2208 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2210 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2211 if(!isWasmInitialized) {
2212 throw new Error("initializeWasm() must be awaited first!");
2214 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
2215 return nativeResponseValue;
2217 // struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2219 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner: bigint): bigint {
2220 if(!isWasmInitialized) {
2221 throw new Error("initializeWasm() must be awaited first!");
2223 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner);
2224 return nativeResponseValue;
2226 // struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2228 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner: bigint): bigint {
2229 if(!isWasmInitialized) {
2230 throw new Error("initializeWasm() must be awaited first!");
2232 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner);
2233 return nativeResponseValue;
2235 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2237 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
2238 if(!isWasmInitialized) {
2239 throw new Error("initializeWasm() must be awaited first!");
2241 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2242 return nativeResponseValue;
2244 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2246 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
2247 if(!isWasmInitialized) {
2248 throw new Error("initializeWasm() must be awaited first!");
2250 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2251 return nativeResponseValue;
2253 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2255 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2256 if(!isWasmInitialized) {
2257 throw new Error("initializeWasm() must be awaited first!");
2259 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2260 return nativeResponseValue;
2262 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2264 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
2265 if(!isWasmInitialized) {
2266 throw new Error("initializeWasm() must be awaited first!");
2268 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2269 return nativeResponseValue;
2271 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2273 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2274 if(!isWasmInitialized) {
2275 throw new Error("initializeWasm() must be awaited first!");
2277 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2278 return nativeResponseValue;
2280 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2282 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2283 if(!isWasmInitialized) {
2284 throw new Error("initializeWasm() must be awaited first!");
2286 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2287 return nativeResponseValue;
2289 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2291 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2292 if(!isWasmInitialized) {
2293 throw new Error("initializeWasm() must be awaited first!");
2295 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2296 return nativeResponseValue;
2298 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2300 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2301 if(!isWasmInitialized) {
2302 throw new Error("initializeWasm() must be awaited first!");
2304 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2305 return nativeResponseValue;
2308 export class LDKCOption_C2Tuple_u64u64ZZ {
2309 protected constructor() {}
2312 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2313 if(!isWasmInitialized) {
2314 throw new Error("initializeWasm() must be awaited first!");
2316 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2317 return nativeResponseValue;
2320 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2321 if(!isWasmInitialized) {
2322 throw new Error("initializeWasm() must be awaited first!");
2324 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2325 return nativeResponseValue;
2327 // struct LDKThirtyTwoU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
2329 export function C2Tuple_Z_get_a(owner: bigint): number {
2330 if(!isWasmInitialized) {
2331 throw new Error("initializeWasm() must be awaited first!");
2333 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
2334 return nativeResponseValue;
2336 // struct LDKThirtyTwoU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
2338 export function C2Tuple_Z_get_b(owner: bigint): number {
2339 if(!isWasmInitialized) {
2340 throw new Error("initializeWasm() must be awaited first!");
2342 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
2343 return nativeResponseValue;
2345 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_a(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2347 export function C2Tuple__u1632_u1632Z_get_a(owner: bigint): number {
2348 if(!isWasmInitialized) {
2349 throw new Error("initializeWasm() must be awaited first!");
2351 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_a(owner);
2352 return nativeResponseValue;
2354 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_b(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2356 export function C2Tuple__u1632_u1632Z_get_b(owner: bigint): number {
2357 if(!isWasmInitialized) {
2358 throw new Error("initializeWasm() must be awaited first!");
2360 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_b(owner);
2361 return nativeResponseValue;
2364 export class LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
2365 protected constructor() {}
2368 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr: bigint): number {
2369 if(!isWasmInitialized) {
2370 throw new Error("initializeWasm() must be awaited first!");
2372 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr);
2373 return nativeResponseValue;
2376 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr: bigint): bigint {
2377 if(!isWasmInitialized) {
2378 throw new Error("initializeWasm() must be awaited first!");
2380 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr);
2381 return nativeResponseValue;
2384 export class LDKCOption_f64Z {
2385 protected constructor() {}
2388 export function LDKCOption_f64Z_ty_from_ptr(ptr: bigint): number {
2389 if(!isWasmInitialized) {
2390 throw new Error("initializeWasm() must be awaited first!");
2392 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_ty_from_ptr(ptr);
2393 return nativeResponseValue;
2396 export function LDKCOption_f64Z_Some_get_some(ptr: bigint): number {
2397 if(!isWasmInitialized) {
2398 throw new Error("initializeWasm() must be awaited first!");
2400 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_Some_get_some(ptr);
2401 return nativeResponseValue;
2404 export interface LDKLogger {
2405 log (record: bigint): void;
2409 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2410 if(!isWasmInitialized) {
2411 throw new Error("initializeWasm() must be awaited first!");
2413 var new_obj_idx = js_objs.length;
2414 for (var i = 0; i < js_objs.length; i++) {
2415 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2417 js_objs[i] = new WeakRef(impl);
2418 return [wasm.TS_LDKLogger_new(i), i];
2420 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2422 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2423 if(!isWasmInitialized) {
2424 throw new Error("initializeWasm() must be awaited first!");
2426 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2427 return nativeResponseValue;
2429 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2431 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2432 if(!isWasmInitialized) {
2433 throw new Error("initializeWasm() must be awaited first!");
2435 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2436 return nativeResponseValue;
2438 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2440 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2441 if(!isWasmInitialized) {
2442 throw new Error("initializeWasm() must be awaited first!");
2444 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2445 return nativeResponseValue;
2447 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2449 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2450 if(!isWasmInitialized) {
2451 throw new Error("initializeWasm() must be awaited first!");
2453 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2454 return nativeResponseValue;
2456 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2458 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(owner: bigint): number {
2459 if(!isWasmInitialized) {
2460 throw new Error("initializeWasm() must be awaited first!");
2462 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(owner);
2463 return nativeResponseValue;
2465 // struct LDKCOption_ThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2467 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(owner: bigint): bigint {
2468 if(!isWasmInitialized) {
2469 throw new Error("initializeWasm() must be awaited first!");
2471 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(owner);
2472 return nativeResponseValue;
2474 // enum LDKChannelMonitorUpdateStatus CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2476 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner: bigint): ChannelMonitorUpdateStatus {
2477 if(!isWasmInitialized) {
2478 throw new Error("initializeWasm() must be awaited first!");
2480 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner);
2481 return nativeResponseValue;
2483 // void CResult_ChannelMonitorUpdateStatusNoneZ_get_err(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2485 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner: bigint): void {
2486 if(!isWasmInitialized) {
2487 throw new Error("initializeWasm() must be awaited first!");
2489 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner);
2490 // debug statements here
2493 export class LDKMonitorEvent {
2494 protected constructor() {}
2497 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2498 if(!isWasmInitialized) {
2499 throw new Error("initializeWasm() must be awaited first!");
2501 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2502 return nativeResponseValue;
2505 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2506 if(!isWasmInitialized) {
2507 throw new Error("initializeWasm() must be awaited first!");
2509 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2510 return nativeResponseValue;
2513 export function LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr: bigint): bigint {
2514 if(!isWasmInitialized) {
2515 throw new Error("initializeWasm() must be awaited first!");
2517 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr);
2518 return nativeResponseValue;
2521 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2522 if(!isWasmInitialized) {
2523 throw new Error("initializeWasm() must be awaited first!");
2525 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2526 return nativeResponseValue;
2529 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2530 if(!isWasmInitialized) {
2531 throw new Error("initializeWasm() must be awaited first!");
2533 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2534 return nativeResponseValue;
2536 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2538 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2539 if(!isWasmInitialized) {
2540 throw new Error("initializeWasm() must be awaited first!");
2542 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2543 return nativeResponseValue;
2545 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2547 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2548 if(!isWasmInitialized) {
2549 throw new Error("initializeWasm() must be awaited first!");
2551 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2552 return nativeResponseValue;
2554 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2556 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2557 if(!isWasmInitialized) {
2558 throw new Error("initializeWasm() must be awaited first!");
2560 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2561 return nativeResponseValue;
2563 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2565 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2566 if(!isWasmInitialized) {
2567 throw new Error("initializeWasm() must be awaited first!");
2569 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2570 return nativeResponseValue;
2572 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2574 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2575 if(!isWasmInitialized) {
2576 throw new Error("initializeWasm() must be awaited first!");
2578 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2579 return nativeResponseValue;
2581 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2583 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2584 if(!isWasmInitialized) {
2585 throw new Error("initializeWasm() must be awaited first!");
2587 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2588 return nativeResponseValue;
2590 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2592 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2593 if(!isWasmInitialized) {
2594 throw new Error("initializeWasm() must be awaited first!");
2596 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2597 return nativeResponseValue;
2599 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2601 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2602 if(!isWasmInitialized) {
2603 throw new Error("initializeWasm() must be awaited first!");
2605 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2606 return nativeResponseValue;
2608 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2610 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2611 if(!isWasmInitialized) {
2612 throw new Error("initializeWasm() must be awaited first!");
2614 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2615 return nativeResponseValue;
2617 // struct LDKBolt11InvoiceFeatures CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2619 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2620 if(!isWasmInitialized) {
2621 throw new Error("initializeWasm() must be awaited first!");
2623 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2624 return nativeResponseValue;
2626 // struct LDKDecodeError CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2628 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2629 if(!isWasmInitialized) {
2630 throw new Error("initializeWasm() must be awaited first!");
2632 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner);
2633 return nativeResponseValue;
2635 // struct LDKBolt12InvoiceFeatures CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2637 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2638 if(!isWasmInitialized) {
2639 throw new Error("initializeWasm() must be awaited first!");
2641 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2642 return nativeResponseValue;
2644 // struct LDKDecodeError CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2646 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2647 if(!isWasmInitialized) {
2648 throw new Error("initializeWasm() must be awaited first!");
2650 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner);
2651 return nativeResponseValue;
2653 // struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2655 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2656 if(!isWasmInitialized) {
2657 throw new Error("initializeWasm() must be awaited first!");
2659 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
2660 return nativeResponseValue;
2662 // struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2664 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2665 if(!isWasmInitialized) {
2666 throw new Error("initializeWasm() must be awaited first!");
2668 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
2669 return nativeResponseValue;
2671 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2673 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2674 if(!isWasmInitialized) {
2675 throw new Error("initializeWasm() must be awaited first!");
2677 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2678 return nativeResponseValue;
2680 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2682 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2683 if(!isWasmInitialized) {
2684 throw new Error("initializeWasm() must be awaited first!");
2686 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2687 return nativeResponseValue;
2689 // struct LDKOffer CResult_OfferBolt12ParseErrorZ_get_ok(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
2691 export function CResult_OfferBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
2692 if(!isWasmInitialized) {
2693 throw new Error("initializeWasm() must be awaited first!");
2695 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_ok(owner);
2696 return nativeResponseValue;
2698 // struct LDKBolt12ParseError CResult_OfferBolt12ParseErrorZ_get_err(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
2700 export function CResult_OfferBolt12ParseErrorZ_get_err(owner: bigint): bigint {
2701 if(!isWasmInitialized) {
2702 throw new Error("initializeWasm() must be awaited first!");
2704 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_err(owner);
2705 return nativeResponseValue;
2707 // struct LDKPublicKey CResult_PublicKeySecp256k1ErrorZ_get_ok(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
2709 export function CResult_PublicKeySecp256k1ErrorZ_get_ok(owner: bigint): number {
2710 if(!isWasmInitialized) {
2711 throw new Error("initializeWasm() must be awaited first!");
2713 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_ok(owner);
2714 return nativeResponseValue;
2716 // enum LDKSecp256k1Error CResult_PublicKeySecp256k1ErrorZ_get_err(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
2718 export function CResult_PublicKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
2719 if(!isWasmInitialized) {
2720 throw new Error("initializeWasm() must be awaited first!");
2722 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_err(owner);
2723 return nativeResponseValue;
2725 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2727 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
2728 if(!isWasmInitialized) {
2729 throw new Error("initializeWasm() must be awaited first!");
2731 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2732 return nativeResponseValue;
2734 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2736 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
2737 if(!isWasmInitialized) {
2738 throw new Error("initializeWasm() must be awaited first!");
2740 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2741 return nativeResponseValue;
2744 export class LDKNetworkUpdate {
2745 protected constructor() {}
2748 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
2749 if(!isWasmInitialized) {
2750 throw new Error("initializeWasm() must be awaited first!");
2752 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
2753 return nativeResponseValue;
2756 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
2757 if(!isWasmInitialized) {
2758 throw new Error("initializeWasm() must be awaited first!");
2760 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
2761 return nativeResponseValue;
2764 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
2765 if(!isWasmInitialized) {
2766 throw new Error("initializeWasm() must be awaited first!");
2768 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
2769 return nativeResponseValue;
2772 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
2773 if(!isWasmInitialized) {
2774 throw new Error("initializeWasm() must be awaited first!");
2776 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
2777 return nativeResponseValue;
2780 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
2781 if(!isWasmInitialized) {
2782 throw new Error("initializeWasm() must be awaited first!");
2784 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
2785 return nativeResponseValue;
2788 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
2789 if(!isWasmInitialized) {
2790 throw new Error("initializeWasm() must be awaited first!");
2792 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
2793 return nativeResponseValue;
2796 export class LDKCOption_NetworkUpdateZ {
2797 protected constructor() {}
2800 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
2801 if(!isWasmInitialized) {
2802 throw new Error("initializeWasm() must be awaited first!");
2804 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
2805 return nativeResponseValue;
2808 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
2809 if(!isWasmInitialized) {
2810 throw new Error("initializeWasm() must be awaited first!");
2812 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
2813 return nativeResponseValue;
2815 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2817 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
2818 if(!isWasmInitialized) {
2819 throw new Error("initializeWasm() must be awaited first!");
2821 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2822 return nativeResponseValue;
2824 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2826 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
2827 if(!isWasmInitialized) {
2828 throw new Error("initializeWasm() must be awaited first!");
2830 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2831 return nativeResponseValue;
2833 // struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
2835 export function CResult_TxOutUtxoLookupErrorZ_get_ok(owner: bigint): bigint {
2836 if(!isWasmInitialized) {
2837 throw new Error("initializeWasm() must be awaited first!");
2839 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_ok(owner);
2840 return nativeResponseValue;
2842 // enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
2844 export function CResult_TxOutUtxoLookupErrorZ_get_err(owner: bigint): UtxoLookupError {
2845 if(!isWasmInitialized) {
2846 throw new Error("initializeWasm() must be awaited first!");
2848 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_err(owner);
2849 return nativeResponseValue;
2852 export class LDKUtxoResult {
2853 protected constructor() {}
2856 export function LDKUtxoResult_ty_from_ptr(ptr: bigint): number {
2857 if(!isWasmInitialized) {
2858 throw new Error("initializeWasm() must be awaited first!");
2860 const nativeResponseValue = wasm.TS_LDKUtxoResult_ty_from_ptr(ptr);
2861 return nativeResponseValue;
2864 export function LDKUtxoResult_Sync_get_sync(ptr: bigint): bigint {
2865 if(!isWasmInitialized) {
2866 throw new Error("initializeWasm() must be awaited first!");
2868 const nativeResponseValue = wasm.TS_LDKUtxoResult_Sync_get_sync(ptr);
2869 return nativeResponseValue;
2872 export function LDKUtxoResult_Async_get_async(ptr: bigint): bigint {
2873 if(!isWasmInitialized) {
2874 throw new Error("initializeWasm() must be awaited first!");
2876 const nativeResponseValue = wasm.TS_LDKUtxoResult_Async_get_async(ptr);
2877 return nativeResponseValue;
2880 export interface LDKUtxoLookup {
2881 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
2885 export function LDKUtxoLookup_new(impl: LDKUtxoLookup): [bigint, number] {
2886 if(!isWasmInitialized) {
2887 throw new Error("initializeWasm() must be awaited first!");
2889 var new_obj_idx = js_objs.length;
2890 for (var i = 0; i < js_objs.length; i++) {
2891 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2893 js_objs[i] = new WeakRef(impl);
2894 return [wasm.TS_LDKUtxoLookup_new(i), i];
2896 // LDKUtxoResult UtxoLookup_get_utxo LDKUtxoLookup *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2898 export function UtxoLookup_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
2899 if(!isWasmInitialized) {
2900 throw new Error("initializeWasm() must be awaited first!");
2902 const nativeResponseValue = wasm.TS_UtxoLookup_get_utxo(this_arg, genesis_hash, short_channel_id);
2903 return nativeResponseValue;
2906 export class LDKCOption_UtxoLookupZ {
2907 protected constructor() {}
2910 export function LDKCOption_UtxoLookupZ_ty_from_ptr(ptr: bigint): number {
2911 if(!isWasmInitialized) {
2912 throw new Error("initializeWasm() must be awaited first!");
2914 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_ty_from_ptr(ptr);
2915 return nativeResponseValue;
2918 export function LDKCOption_UtxoLookupZ_Some_get_some(ptr: bigint): bigint {
2919 if(!isWasmInitialized) {
2920 throw new Error("initializeWasm() must be awaited first!");
2922 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_Some_get_some(ptr);
2923 return nativeResponseValue;
2925 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2927 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
2928 if(!isWasmInitialized) {
2929 throw new Error("initializeWasm() must be awaited first!");
2931 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2932 // debug statements here
2934 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2936 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
2937 if(!isWasmInitialized) {
2938 throw new Error("initializeWasm() must be awaited first!");
2940 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2941 return nativeResponseValue;
2943 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2945 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
2946 if(!isWasmInitialized) {
2947 throw new Error("initializeWasm() must be awaited first!");
2949 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2950 return nativeResponseValue;
2952 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2954 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
2955 if(!isWasmInitialized) {
2956 throw new Error("initializeWasm() must be awaited first!");
2958 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2959 return nativeResponseValue;
2961 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2963 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
2964 if(!isWasmInitialized) {
2965 throw new Error("initializeWasm() must be awaited first!");
2967 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2968 return nativeResponseValue;
2970 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2972 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
2973 if(!isWasmInitialized) {
2974 throw new Error("initializeWasm() must be awaited first!");
2976 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2977 return nativeResponseValue;
2979 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2981 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
2982 if(!isWasmInitialized) {
2983 throw new Error("initializeWasm() must be awaited first!");
2985 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2986 return nativeResponseValue;
2989 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
2990 protected constructor() {}
2993 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
2994 if(!isWasmInitialized) {
2995 throw new Error("initializeWasm() must be awaited first!");
2997 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
2998 return nativeResponseValue;
3001 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
3002 if(!isWasmInitialized) {
3003 throw new Error("initializeWasm() must be awaited first!");
3005 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
3006 return nativeResponseValue;
3009 export class LDKErrorAction {
3010 protected constructor() {}
3013 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
3014 if(!isWasmInitialized) {
3015 throw new Error("initializeWasm() must be awaited first!");
3017 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
3018 return nativeResponseValue;
3021 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
3022 if(!isWasmInitialized) {
3023 throw new Error("initializeWasm() must be awaited first!");
3025 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
3026 return nativeResponseValue;
3029 export function LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr: bigint): bigint {
3030 if(!isWasmInitialized) {
3031 throw new Error("initializeWasm() must be awaited first!");
3033 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr);
3034 return nativeResponseValue;
3037 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
3038 if(!isWasmInitialized) {
3039 throw new Error("initializeWasm() must be awaited first!");
3041 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
3042 return nativeResponseValue;
3045 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
3050 return nativeResponseValue;
3053 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
3054 if(!isWasmInitialized) {
3055 throw new Error("initializeWasm() must be awaited first!");
3057 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
3058 return nativeResponseValue;
3061 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
3062 if(!isWasmInitialized) {
3063 throw new Error("initializeWasm() must be awaited first!");
3065 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
3066 return nativeResponseValue;
3069 export class LDKMessageSendEvent {
3070 protected constructor() {}
3073 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
3074 if(!isWasmInitialized) {
3075 throw new Error("initializeWasm() must be awaited first!");
3077 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
3078 return nativeResponseValue;
3081 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
3086 return nativeResponseValue;
3089 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
3090 if(!isWasmInitialized) {
3091 throw new Error("initializeWasm() must be awaited first!");
3093 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
3094 return nativeResponseValue;
3097 export function LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr: bigint): number {
3098 if(!isWasmInitialized) {
3099 throw new Error("initializeWasm() must be awaited first!");
3101 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr);
3102 return nativeResponseValue;
3105 export function LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr: bigint): bigint {
3106 if(!isWasmInitialized) {
3107 throw new Error("initializeWasm() must be awaited first!");
3109 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr);
3110 return nativeResponseValue;
3113 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
3114 if(!isWasmInitialized) {
3115 throw new Error("initializeWasm() must be awaited first!");
3117 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
3118 return nativeResponseValue;
3121 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
3122 if(!isWasmInitialized) {
3123 throw new Error("initializeWasm() must be awaited first!");
3125 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
3126 return nativeResponseValue;
3129 export function LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr: bigint): number {
3130 if(!isWasmInitialized) {
3131 throw new Error("initializeWasm() must be awaited first!");
3133 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr);
3134 return nativeResponseValue;
3137 export function LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr: bigint): bigint {
3138 if(!isWasmInitialized) {
3139 throw new Error("initializeWasm() must be awaited first!");
3141 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr);
3142 return nativeResponseValue;
3145 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
3146 if(!isWasmInitialized) {
3147 throw new Error("initializeWasm() must be awaited first!");
3149 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
3150 return nativeResponseValue;
3153 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
3158 return nativeResponseValue;
3161 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
3162 if(!isWasmInitialized) {
3163 throw new Error("initializeWasm() must be awaited first!");
3165 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
3166 return nativeResponseValue;
3169 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
3170 if(!isWasmInitialized) {
3171 throw new Error("initializeWasm() must be awaited first!");
3173 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
3174 return nativeResponseValue;
3177 export function LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr: bigint): number {
3178 if(!isWasmInitialized) {
3179 throw new Error("initializeWasm() must be awaited first!");
3181 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr);
3182 return nativeResponseValue;
3185 export function LDKMessageSendEvent_SendTxAddInput_get_msg(ptr: bigint): bigint {
3186 if(!isWasmInitialized) {
3187 throw new Error("initializeWasm() must be awaited first!");
3189 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_msg(ptr);
3190 return nativeResponseValue;
3193 export function LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr: bigint): number {
3194 if(!isWasmInitialized) {
3195 throw new Error("initializeWasm() must be awaited first!");
3197 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr);
3198 return nativeResponseValue;
3201 export function LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr: bigint): bigint {
3202 if(!isWasmInitialized) {
3203 throw new Error("initializeWasm() must be awaited first!");
3205 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr);
3206 return nativeResponseValue;
3209 export function LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr: bigint): number {
3210 if(!isWasmInitialized) {
3211 throw new Error("initializeWasm() must be awaited first!");
3213 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr);
3214 return nativeResponseValue;
3217 export function LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr: bigint): bigint {
3218 if(!isWasmInitialized) {
3219 throw new Error("initializeWasm() must be awaited first!");
3221 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr);
3222 return nativeResponseValue;
3225 export function LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr: bigint): number {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr);
3230 return nativeResponseValue;
3233 export function LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr: bigint): bigint {
3234 if(!isWasmInitialized) {
3235 throw new Error("initializeWasm() must be awaited first!");
3237 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr);
3238 return nativeResponseValue;
3241 export function LDKMessageSendEvent_SendTxComplete_get_node_id(ptr: bigint): number {
3242 if(!isWasmInitialized) {
3243 throw new Error("initializeWasm() must be awaited first!");
3245 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_node_id(ptr);
3246 return nativeResponseValue;
3249 export function LDKMessageSendEvent_SendTxComplete_get_msg(ptr: bigint): bigint {
3250 if(!isWasmInitialized) {
3251 throw new Error("initializeWasm() must be awaited first!");
3253 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_msg(ptr);
3254 return nativeResponseValue;
3257 export function LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr: bigint): number {
3258 if(!isWasmInitialized) {
3259 throw new Error("initializeWasm() must be awaited first!");
3261 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr);
3262 return nativeResponseValue;
3265 export function LDKMessageSendEvent_SendTxSignatures_get_msg(ptr: bigint): bigint {
3266 if(!isWasmInitialized) {
3267 throw new Error("initializeWasm() must be awaited first!");
3269 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_msg(ptr);
3270 return nativeResponseValue;
3273 export function LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr: bigint): number {
3274 if(!isWasmInitialized) {
3275 throw new Error("initializeWasm() must be awaited first!");
3277 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr);
3278 return nativeResponseValue;
3281 export function LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr: bigint): bigint {
3282 if(!isWasmInitialized) {
3283 throw new Error("initializeWasm() must be awaited first!");
3285 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr);
3286 return nativeResponseValue;
3289 export function LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr: bigint): number {
3290 if(!isWasmInitialized) {
3291 throw new Error("initializeWasm() must be awaited first!");
3293 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr);
3294 return nativeResponseValue;
3297 export function LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr: bigint): bigint {
3298 if(!isWasmInitialized) {
3299 throw new Error("initializeWasm() must be awaited first!");
3301 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr);
3302 return nativeResponseValue;
3305 export function LDKMessageSendEvent_SendTxAbort_get_node_id(ptr: bigint): number {
3306 if(!isWasmInitialized) {
3307 throw new Error("initializeWasm() must be awaited first!");
3309 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_node_id(ptr);
3310 return nativeResponseValue;
3313 export function LDKMessageSendEvent_SendTxAbort_get_msg(ptr: bigint): bigint {
3314 if(!isWasmInitialized) {
3315 throw new Error("initializeWasm() must be awaited first!");
3317 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_msg(ptr);
3318 return nativeResponseValue;
3321 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
3322 if(!isWasmInitialized) {
3323 throw new Error("initializeWasm() must be awaited first!");
3325 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
3326 return nativeResponseValue;
3329 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
3330 if(!isWasmInitialized) {
3331 throw new Error("initializeWasm() must be awaited first!");
3333 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
3334 return nativeResponseValue;
3337 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
3338 if(!isWasmInitialized) {
3339 throw new Error("initializeWasm() must be awaited first!");
3341 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
3342 return nativeResponseValue;
3345 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
3346 if(!isWasmInitialized) {
3347 throw new Error("initializeWasm() must be awaited first!");
3349 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
3350 return nativeResponseValue;
3353 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
3354 if(!isWasmInitialized) {
3355 throw new Error("initializeWasm() must be awaited first!");
3357 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
3358 return nativeResponseValue;
3361 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
3362 if(!isWasmInitialized) {
3363 throw new Error("initializeWasm() must be awaited first!");
3365 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
3366 return nativeResponseValue;
3369 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
3370 if(!isWasmInitialized) {
3371 throw new Error("initializeWasm() must be awaited first!");
3373 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
3374 return nativeResponseValue;
3377 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
3378 if(!isWasmInitialized) {
3379 throw new Error("initializeWasm() must be awaited first!");
3381 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
3382 return nativeResponseValue;
3385 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
3386 if(!isWasmInitialized) {
3387 throw new Error("initializeWasm() must be awaited first!");
3389 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
3390 return nativeResponseValue;
3393 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
3394 if(!isWasmInitialized) {
3395 throw new Error("initializeWasm() must be awaited first!");
3397 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
3398 return nativeResponseValue;
3401 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
3402 if(!isWasmInitialized) {
3403 throw new Error("initializeWasm() must be awaited first!");
3405 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
3406 return nativeResponseValue;
3409 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
3410 if(!isWasmInitialized) {
3411 throw new Error("initializeWasm() must be awaited first!");
3413 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
3414 return nativeResponseValue;
3417 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
3418 if(!isWasmInitialized) {
3419 throw new Error("initializeWasm() must be awaited first!");
3421 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
3422 return nativeResponseValue;
3425 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
3426 if(!isWasmInitialized) {
3427 throw new Error("initializeWasm() must be awaited first!");
3429 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
3430 return nativeResponseValue;
3433 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
3434 if(!isWasmInitialized) {
3435 throw new Error("initializeWasm() must be awaited first!");
3437 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
3438 return nativeResponseValue;
3441 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
3442 if(!isWasmInitialized) {
3443 throw new Error("initializeWasm() must be awaited first!");
3445 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
3446 return nativeResponseValue;
3449 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
3450 if(!isWasmInitialized) {
3451 throw new Error("initializeWasm() must be awaited first!");
3453 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
3454 return nativeResponseValue;
3457 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
3458 if(!isWasmInitialized) {
3459 throw new Error("initializeWasm() must be awaited first!");
3461 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
3462 return nativeResponseValue;
3465 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
3466 if(!isWasmInitialized) {
3467 throw new Error("initializeWasm() must be awaited first!");
3469 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
3470 return nativeResponseValue;
3473 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
3474 if(!isWasmInitialized) {
3475 throw new Error("initializeWasm() must be awaited first!");
3477 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
3478 return nativeResponseValue;
3481 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
3482 if(!isWasmInitialized) {
3483 throw new Error("initializeWasm() must be awaited first!");
3485 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
3486 return nativeResponseValue;
3489 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
3490 if(!isWasmInitialized) {
3491 throw new Error("initializeWasm() must be awaited first!");
3493 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
3494 return nativeResponseValue;
3497 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
3498 if(!isWasmInitialized) {
3499 throw new Error("initializeWasm() must be awaited first!");
3501 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
3502 return nativeResponseValue;
3505 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
3506 if(!isWasmInitialized) {
3507 throw new Error("initializeWasm() must be awaited first!");
3509 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
3510 return nativeResponseValue;
3513 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
3514 if(!isWasmInitialized) {
3515 throw new Error("initializeWasm() must be awaited first!");
3517 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
3518 return nativeResponseValue;
3521 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
3522 if(!isWasmInitialized) {
3523 throw new Error("initializeWasm() must be awaited first!");
3525 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
3526 return nativeResponseValue;
3529 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
3530 if(!isWasmInitialized) {
3531 throw new Error("initializeWasm() must be awaited first!");
3533 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
3534 return nativeResponseValue;
3537 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
3538 if(!isWasmInitialized) {
3539 throw new Error("initializeWasm() must be awaited first!");
3541 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
3542 return nativeResponseValue;
3545 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
3546 if(!isWasmInitialized) {
3547 throw new Error("initializeWasm() must be awaited first!");
3549 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
3550 return nativeResponseValue;
3553 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
3554 if(!isWasmInitialized) {
3555 throw new Error("initializeWasm() must be awaited first!");
3557 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
3558 return nativeResponseValue;
3561 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
3562 if(!isWasmInitialized) {
3563 throw new Error("initializeWasm() must be awaited first!");
3565 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
3566 return nativeResponseValue;
3569 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
3570 if(!isWasmInitialized) {
3571 throw new Error("initializeWasm() must be awaited first!");
3573 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
3574 return nativeResponseValue;
3577 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
3578 if(!isWasmInitialized) {
3579 throw new Error("initializeWasm() must be awaited first!");
3581 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
3582 return nativeResponseValue;
3584 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3586 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3587 if(!isWasmInitialized) {
3588 throw new Error("initializeWasm() must be awaited first!");
3590 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
3591 return nativeResponseValue;
3593 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3595 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3596 if(!isWasmInitialized) {
3597 throw new Error("initializeWasm() must be awaited first!");
3599 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
3600 return nativeResponseValue;
3602 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3604 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3605 if(!isWasmInitialized) {
3606 throw new Error("initializeWasm() must be awaited first!");
3608 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
3609 return nativeResponseValue;
3611 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3613 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3614 if(!isWasmInitialized) {
3615 throw new Error("initializeWasm() must be awaited first!");
3617 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
3618 return nativeResponseValue;
3620 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3622 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
3623 if(!isWasmInitialized) {
3624 throw new Error("initializeWasm() must be awaited first!");
3626 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
3627 return nativeResponseValue;
3629 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3631 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
3632 if(!isWasmInitialized) {
3633 throw new Error("initializeWasm() must be awaited first!");
3635 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
3636 return nativeResponseValue;
3639 export class LDKSocketAddress {
3640 protected constructor() {}
3643 export function LDKSocketAddress_ty_from_ptr(ptr: bigint): number {
3644 if(!isWasmInitialized) {
3645 throw new Error("initializeWasm() must be awaited first!");
3647 const nativeResponseValue = wasm.TS_LDKSocketAddress_ty_from_ptr(ptr);
3648 return nativeResponseValue;
3651 export function LDKSocketAddress_TcpIpV4_get_addr(ptr: bigint): number {
3652 if(!isWasmInitialized) {
3653 throw new Error("initializeWasm() must be awaited first!");
3655 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_addr(ptr);
3656 return nativeResponseValue;
3659 export function LDKSocketAddress_TcpIpV4_get_port(ptr: bigint): number {
3660 if(!isWasmInitialized) {
3661 throw new Error("initializeWasm() must be awaited first!");
3663 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_port(ptr);
3664 return nativeResponseValue;
3667 export function LDKSocketAddress_TcpIpV6_get_addr(ptr: bigint): number {
3668 if(!isWasmInitialized) {
3669 throw new Error("initializeWasm() must be awaited first!");
3671 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_addr(ptr);
3672 return nativeResponseValue;
3675 export function LDKSocketAddress_TcpIpV6_get_port(ptr: bigint): number {
3676 if(!isWasmInitialized) {
3677 throw new Error("initializeWasm() must be awaited first!");
3679 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_port(ptr);
3680 return nativeResponseValue;
3683 export function LDKSocketAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3684 if(!isWasmInitialized) {
3685 throw new Error("initializeWasm() must be awaited first!");
3687 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV2_get_onion_v2(ptr);
3688 return nativeResponseValue;
3691 export function LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3692 if(!isWasmInitialized) {
3693 throw new Error("initializeWasm() must be awaited first!");
3695 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr);
3696 return nativeResponseValue;
3699 export function LDKSocketAddress_OnionV3_get_checksum(ptr: bigint): number {
3700 if(!isWasmInitialized) {
3701 throw new Error("initializeWasm() must be awaited first!");
3703 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_checksum(ptr);
3704 return nativeResponseValue;
3707 export function LDKSocketAddress_OnionV3_get_version(ptr: bigint): number {
3708 if(!isWasmInitialized) {
3709 throw new Error("initializeWasm() must be awaited first!");
3711 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_version(ptr);
3712 return nativeResponseValue;
3715 export function LDKSocketAddress_OnionV3_get_port(ptr: bigint): number {
3716 if(!isWasmInitialized) {
3717 throw new Error("initializeWasm() must be awaited first!");
3719 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_port(ptr);
3720 return nativeResponseValue;
3723 export function LDKSocketAddress_Hostname_get_hostname(ptr: bigint): bigint {
3724 if(!isWasmInitialized) {
3725 throw new Error("initializeWasm() must be awaited first!");
3727 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_hostname(ptr);
3728 return nativeResponseValue;
3731 export function LDKSocketAddress_Hostname_get_port(ptr: bigint): number {
3732 if(!isWasmInitialized) {
3733 throw new Error("initializeWasm() must be awaited first!");
3735 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_port(ptr);
3736 return nativeResponseValue;
3738 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3740 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3741 if(!isWasmInitialized) {
3742 throw new Error("initializeWasm() must be awaited first!");
3744 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3745 return nativeResponseValue;
3747 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3749 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3750 if(!isWasmInitialized) {
3751 throw new Error("initializeWasm() must be awaited first!");
3753 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3754 return nativeResponseValue;
3756 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3758 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3759 if(!isWasmInitialized) {
3760 throw new Error("initializeWasm() must be awaited first!");
3762 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3763 return nativeResponseValue;
3765 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3767 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3768 if(!isWasmInitialized) {
3769 throw new Error("initializeWasm() must be awaited first!");
3771 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3772 return nativeResponseValue;
3774 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3776 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3777 if(!isWasmInitialized) {
3778 throw new Error("initializeWasm() must be awaited first!");
3780 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3781 return nativeResponseValue;
3783 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3785 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3786 if(!isWasmInitialized) {
3787 throw new Error("initializeWasm() must be awaited first!");
3789 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3790 return nativeResponseValue;
3792 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3794 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3795 if(!isWasmInitialized) {
3796 throw new Error("initializeWasm() must be awaited first!");
3798 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3799 return nativeResponseValue;
3801 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3803 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3804 if(!isWasmInitialized) {
3805 throw new Error("initializeWasm() must be awaited first!");
3807 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3808 return nativeResponseValue;
3811 export class LDKCOption_CVec_SocketAddressZZ {
3812 protected constructor() {}
3815 export function LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr: bigint): number {
3816 if(!isWasmInitialized) {
3817 throw new Error("initializeWasm() must be awaited first!");
3819 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr);
3820 return nativeResponseValue;
3823 export function LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr: bigint): number {
3824 if(!isWasmInitialized) {
3825 throw new Error("initializeWasm() must be awaited first!");
3827 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr);
3828 return nativeResponseValue;
3830 // struct LDKChannelDerivationParameters CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
3832 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
3833 if(!isWasmInitialized) {
3834 throw new Error("initializeWasm() must be awaited first!");
3836 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner);
3837 return nativeResponseValue;
3839 // struct LDKDecodeError CResult_ChannelDerivationParametersDecodeErrorZ_get_err(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
3841 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner: bigint): bigint {
3842 if(!isWasmInitialized) {
3843 throw new Error("initializeWasm() must be awaited first!");
3845 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner);
3846 return nativeResponseValue;
3848 // struct LDKHTLCDescriptor CResult_HTLCDescriptorDecodeErrorZ_get_ok(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
3850 export function CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3851 if(!isWasmInitialized) {
3852 throw new Error("initializeWasm() must be awaited first!");
3854 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner);
3855 return nativeResponseValue;
3857 // struct LDKDecodeError CResult_HTLCDescriptorDecodeErrorZ_get_err(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
3859 export function CResult_HTLCDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3860 if(!isWasmInitialized) {
3861 throw new Error("initializeWasm() must be awaited first!");
3863 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_err(owner);
3864 return nativeResponseValue;
3867 export class LDKCOption_TxOutZ {
3868 protected constructor() {}
3871 export function LDKCOption_TxOutZ_ty_from_ptr(ptr: bigint): number {
3872 if(!isWasmInitialized) {
3873 throw new Error("initializeWasm() must be awaited first!");
3875 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_ty_from_ptr(ptr);
3876 return nativeResponseValue;
3879 export function LDKCOption_TxOutZ_Some_get_some(ptr: bigint): bigint {
3880 if(!isWasmInitialized) {
3881 throw new Error("initializeWasm() must be awaited first!");
3883 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_Some_get_some(ptr);
3884 return nativeResponseValue;
3886 // struct LDKCoinSelection CResult_CoinSelectionNoneZ_get_ok(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
3888 export function CResult_CoinSelectionNoneZ_get_ok(owner: bigint): bigint {
3889 if(!isWasmInitialized) {
3890 throw new Error("initializeWasm() must be awaited first!");
3892 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_ok(owner);
3893 return nativeResponseValue;
3895 // void CResult_CoinSelectionNoneZ_get_err(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
3897 export function CResult_CoinSelectionNoneZ_get_err(owner: bigint): void {
3898 if(!isWasmInitialized) {
3899 throw new Error("initializeWasm() must be awaited first!");
3901 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_err(owner);
3902 // debug statements here
3904 // struct LDKCVec_UtxoZ CResult_CVec_UtxoZNoneZ_get_ok(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
3906 export function CResult_CVec_UtxoZNoneZ_get_ok(owner: bigint): number {
3907 if(!isWasmInitialized) {
3908 throw new Error("initializeWasm() must be awaited first!");
3910 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_ok(owner);
3911 return nativeResponseValue;
3913 // void CResult_CVec_UtxoZNoneZ_get_err(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
3915 export function CResult_CVec_UtxoZNoneZ_get_err(owner: bigint): void {
3916 if(!isWasmInitialized) {
3917 throw new Error("initializeWasm() must be awaited first!");
3919 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_err(owner);
3920 // debug statements here
3922 // uint64_t C2Tuple_u64u16Z_get_a(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
3924 export function C2Tuple_u64u16Z_get_a(owner: bigint): bigint {
3925 if(!isWasmInitialized) {
3926 throw new Error("initializeWasm() must be awaited first!");
3928 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_a(owner);
3929 return nativeResponseValue;
3931 // uint16_t C2Tuple_u64u16Z_get_b(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
3933 export function C2Tuple_u64u16Z_get_b(owner: bigint): number {
3934 if(!isWasmInitialized) {
3935 throw new Error("initializeWasm() must be awaited first!");
3937 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_b(owner);
3938 return nativeResponseValue;
3941 export class LDKCOption_C2Tuple_u64u16ZZ {
3942 protected constructor() {}
3945 export function LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr: bigint): number {
3946 if(!isWasmInitialized) {
3947 throw new Error("initializeWasm() must be awaited first!");
3949 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr);
3950 return nativeResponseValue;
3953 export function LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr: bigint): bigint {
3954 if(!isWasmInitialized) {
3955 throw new Error("initializeWasm() must be awaited first!");
3957 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr);
3958 return nativeResponseValue;
3961 export class LDKCOption_ChannelShutdownStateZ {
3962 protected constructor() {}
3965 export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
3966 if(!isWasmInitialized) {
3967 throw new Error("initializeWasm() must be awaited first!");
3969 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
3970 return nativeResponseValue;
3973 export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
3974 if(!isWasmInitialized) {
3975 throw new Error("initializeWasm() must be awaited first!");
3977 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
3978 return nativeResponseValue;
3980 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesAPIErrorZ_get_ok(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
3982 export function CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner: bigint): number {
3983 if(!isWasmInitialized) {
3984 throw new Error("initializeWasm() must be awaited first!");
3986 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner);
3987 return nativeResponseValue;
3989 // struct LDKAPIError CResult_ThirtyTwoBytesAPIErrorZ_get_err(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
3991 export function CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner: bigint): bigint {
3992 if(!isWasmInitialized) {
3993 throw new Error("initializeWasm() must be awaited first!");
3995 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner);
3996 return nativeResponseValue;
3999 export class LDKRecentPaymentDetails {
4000 protected constructor() {}
4003 export function LDKRecentPaymentDetails_ty_from_ptr(ptr: bigint): number {
4004 if(!isWasmInitialized) {
4005 throw new Error("initializeWasm() must be awaited first!");
4007 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_ty_from_ptr(ptr);
4008 return nativeResponseValue;
4011 export function LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr: bigint): number {
4012 if(!isWasmInitialized) {
4013 throw new Error("initializeWasm() must be awaited first!");
4015 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr);
4016 return nativeResponseValue;
4019 export function LDKRecentPaymentDetails_Pending_get_payment_id(ptr: bigint): number {
4020 if(!isWasmInitialized) {
4021 throw new Error("initializeWasm() must be awaited first!");
4023 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_id(ptr);
4024 return nativeResponseValue;
4027 export function LDKRecentPaymentDetails_Pending_get_payment_hash(ptr: bigint): number {
4028 if(!isWasmInitialized) {
4029 throw new Error("initializeWasm() must be awaited first!");
4031 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
4032 return nativeResponseValue;
4035 export function LDKRecentPaymentDetails_Pending_get_total_msat(ptr: bigint): bigint {
4036 if(!isWasmInitialized) {
4037 throw new Error("initializeWasm() must be awaited first!");
4039 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
4040 return nativeResponseValue;
4043 export function LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr: bigint): number {
4044 if(!isWasmInitialized) {
4045 throw new Error("initializeWasm() must be awaited first!");
4047 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr);
4048 return nativeResponseValue;
4051 export function LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr: bigint): bigint {
4052 if(!isWasmInitialized) {
4053 throw new Error("initializeWasm() must be awaited first!");
4055 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
4056 return nativeResponseValue;
4059 export function LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr: bigint): number {
4060 if(!isWasmInitialized) {
4061 throw new Error("initializeWasm() must be awaited first!");
4063 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr);
4064 return nativeResponseValue;
4067 export function LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr: bigint): number {
4068 if(!isWasmInitialized) {
4069 throw new Error("initializeWasm() must be awaited first!");
4071 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
4072 return nativeResponseValue;
4075 export class LDKPaymentSendFailure {
4076 protected constructor() {}
4079 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
4080 if(!isWasmInitialized) {
4081 throw new Error("initializeWasm() must be awaited first!");
4083 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4084 return nativeResponseValue;
4087 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4092 return nativeResponseValue;
4095 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
4096 if(!isWasmInitialized) {
4097 throw new Error("initializeWasm() must be awaited first!");
4099 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4100 return nativeResponseValue;
4103 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
4104 if(!isWasmInitialized) {
4105 throw new Error("initializeWasm() must be awaited first!");
4107 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
4108 return nativeResponseValue;
4111 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
4112 if(!isWasmInitialized) {
4113 throw new Error("initializeWasm() must be awaited first!");
4115 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4116 return nativeResponseValue;
4119 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
4120 if(!isWasmInitialized) {
4121 throw new Error("initializeWasm() must be awaited first!");
4123 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4124 return nativeResponseValue;
4127 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
4128 if(!isWasmInitialized) {
4129 throw new Error("initializeWasm() must be awaited first!");
4131 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4132 return nativeResponseValue;
4134 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4136 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
4137 if(!isWasmInitialized) {
4138 throw new Error("initializeWasm() must be awaited first!");
4140 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4141 // debug statements here
4143 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4145 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
4146 if(!isWasmInitialized) {
4147 throw new Error("initializeWasm() must be awaited first!");
4149 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4150 return nativeResponseValue;
4152 // void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4154 export function CResult_NoneRetryableSendFailureZ_get_ok(owner: bigint): void {
4155 if(!isWasmInitialized) {
4156 throw new Error("initializeWasm() must be awaited first!");
4158 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_ok(owner);
4159 // debug statements here
4161 // enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4163 export function CResult_NoneRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4164 if(!isWasmInitialized) {
4165 throw new Error("initializeWasm() must be awaited first!");
4167 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_err(owner);
4168 return nativeResponseValue;
4170 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4172 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner: bigint): number {
4173 if(!isWasmInitialized) {
4174 throw new Error("initializeWasm() must be awaited first!");
4176 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner);
4177 return nativeResponseValue;
4179 // struct LDKPaymentSendFailure CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4181 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner: bigint): bigint {
4182 if(!isWasmInitialized) {
4183 throw new Error("initializeWasm() must be awaited first!");
4185 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner);
4186 return nativeResponseValue;
4188 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4190 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner: bigint): number {
4191 if(!isWasmInitialized) {
4192 throw new Error("initializeWasm() must be awaited first!");
4194 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner);
4195 return nativeResponseValue;
4197 // enum LDKRetryableSendFailure CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4199 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4200 if(!isWasmInitialized) {
4201 throw new Error("initializeWasm() must be awaited first!");
4203 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner);
4204 return nativeResponseValue;
4206 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4208 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner: bigint): number {
4209 if(!isWasmInitialized) {
4210 throw new Error("initializeWasm() must be awaited first!");
4212 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner);
4213 return nativeResponseValue;
4215 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4217 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner: bigint): number {
4218 if(!isWasmInitialized) {
4219 throw new Error("initializeWasm() must be awaited first!");
4221 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner);
4222 return nativeResponseValue;
4224 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4226 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
4227 if(!isWasmInitialized) {
4228 throw new Error("initializeWasm() must be awaited first!");
4230 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner);
4231 return nativeResponseValue;
4233 // struct LDKPaymentSendFailure CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4235 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner: bigint): bigint {
4236 if(!isWasmInitialized) {
4237 throw new Error("initializeWasm() must be awaited first!");
4239 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner);
4240 return nativeResponseValue;
4243 export class LDKProbeSendFailure {
4244 protected constructor() {}
4247 export function LDKProbeSendFailure_ty_from_ptr(ptr: bigint): number {
4248 if(!isWasmInitialized) {
4249 throw new Error("initializeWasm() must be awaited first!");
4251 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_ty_from_ptr(ptr);
4252 return nativeResponseValue;
4255 export function LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr: bigint): bigint {
4256 if(!isWasmInitialized) {
4257 throw new Error("initializeWasm() must be awaited first!");
4259 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr);
4260 return nativeResponseValue;
4262 // struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4264 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner: bigint): number {
4265 if(!isWasmInitialized) {
4266 throw new Error("initializeWasm() must be awaited first!");
4268 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner);
4269 return nativeResponseValue;
4271 // struct LDKProbeSendFailure CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4273 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner: bigint): bigint {
4274 if(!isWasmInitialized) {
4275 throw new Error("initializeWasm() must be awaited first!");
4277 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner);
4278 return nativeResponseValue;
4280 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner);
4282 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner: bigint): number {
4283 if(!isWasmInitialized) {
4284 throw new Error("initializeWasm() must be awaited first!");
4286 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner);
4287 return nativeResponseValue;
4289 // struct LDKPublicKey C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner);
4291 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner: bigint): number {
4292 if(!isWasmInitialized) {
4293 throw new Error("initializeWasm() must be awaited first!");
4295 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner);
4296 return nativeResponseValue;
4298 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4300 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner: bigint): bigint {
4301 if(!isWasmInitialized) {
4302 throw new Error("initializeWasm() must be awaited first!");
4304 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner);
4305 return nativeResponseValue;
4307 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4309 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner: bigint): void {
4310 if(!isWasmInitialized) {
4311 throw new Error("initializeWasm() must be awaited first!");
4313 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner);
4314 // debug statements here
4316 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4318 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4319 if(!isWasmInitialized) {
4320 throw new Error("initializeWasm() must be awaited first!");
4322 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4323 return nativeResponseValue;
4325 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4327 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4328 if(!isWasmInitialized) {
4329 throw new Error("initializeWasm() must be awaited first!");
4331 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4332 return nativeResponseValue;
4334 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4336 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4337 if(!isWasmInitialized) {
4338 throw new Error("initializeWasm() must be awaited first!");
4340 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4341 return nativeResponseValue;
4343 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4345 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4346 if(!isWasmInitialized) {
4347 throw new Error("initializeWasm() must be awaited first!");
4349 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4350 return nativeResponseValue;
4352 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4354 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4355 if(!isWasmInitialized) {
4356 throw new Error("initializeWasm() must be awaited first!");
4358 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4359 return nativeResponseValue;
4361 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4363 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4364 if(!isWasmInitialized) {
4365 throw new Error("initializeWasm() must be awaited first!");
4367 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4368 return nativeResponseValue;
4370 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4372 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4373 if(!isWasmInitialized) {
4374 throw new Error("initializeWasm() must be awaited first!");
4376 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4377 return nativeResponseValue;
4379 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4381 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4386 return nativeResponseValue;
4388 // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
4390 export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
4391 if(!isWasmInitialized) {
4392 throw new Error("initializeWasm() must be awaited first!");
4394 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
4395 return nativeResponseValue;
4397 // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
4399 export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
4400 if(!isWasmInitialized) {
4401 throw new Error("initializeWasm() must be awaited first!");
4403 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
4404 return nativeResponseValue;
4407 export interface LDKWatch {
4408 watch_channel (funding_txo: bigint, monitor: bigint): bigint;
4409 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
4410 release_pending_monitor_events (): number;
4414 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4415 if(!isWasmInitialized) {
4416 throw new Error("initializeWasm() must be awaited first!");
4418 var new_obj_idx = js_objs.length;
4419 for (var i = 0; i < js_objs.length; i++) {
4420 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4422 js_objs[i] = new WeakRef(impl);
4423 return [wasm.TS_LDKWatch_new(i), i];
4425 // LDKCResult_ChannelMonitorUpdateStatusNoneZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4427 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): bigint {
4428 if(!isWasmInitialized) {
4429 throw new Error("initializeWasm() must be awaited first!");
4431 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4432 return nativeResponseValue;
4434 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update
4436 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
4437 if(!isWasmInitialized) {
4438 throw new Error("initializeWasm() must be awaited first!");
4440 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4441 return nativeResponseValue;
4443 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4445 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4446 if(!isWasmInitialized) {
4447 throw new Error("initializeWasm() must be awaited first!");
4449 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4450 return nativeResponseValue;
4453 export interface LDKBroadcasterInterface {
4454 broadcast_transactions (txs: number): void;
4458 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4459 if(!isWasmInitialized) {
4460 throw new Error("initializeWasm() must be awaited first!");
4462 var new_obj_idx = js_objs.length;
4463 for (var i = 0; i < js_objs.length; i++) {
4464 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4466 js_objs[i] = new WeakRef(impl);
4467 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4469 // void BroadcasterInterface_broadcast_transactions LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKCVec_TransactionZ txs
4471 export function BroadcasterInterface_broadcast_transactions(this_arg: bigint, txs: number): void {
4472 if(!isWasmInitialized) {
4473 throw new Error("initializeWasm() must be awaited first!");
4475 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transactions(this_arg, txs);
4476 // debug statements here
4479 export interface LDKEntropySource {
4480 get_secure_random_bytes (): number;
4484 export function LDKEntropySource_new(impl: LDKEntropySource): [bigint, number] {
4485 if(!isWasmInitialized) {
4486 throw new Error("initializeWasm() must be awaited first!");
4488 var new_obj_idx = js_objs.length;
4489 for (var i = 0; i < js_objs.length; i++) {
4490 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4492 js_objs[i] = new WeakRef(impl);
4493 return [wasm.TS_LDKEntropySource_new(i), i];
4495 // LDKThirtyTwoBytes EntropySource_get_secure_random_bytes LDKEntropySource *NONNULL_PTR this_arg
4497 export function EntropySource_get_secure_random_bytes(this_arg: bigint): number {
4498 if(!isWasmInitialized) {
4499 throw new Error("initializeWasm() must be awaited first!");
4501 const nativeResponseValue = wasm.TS_EntropySource_get_secure_random_bytes(this_arg);
4502 return nativeResponseValue;
4505 export class LDKUnsignedGossipMessage {
4506 protected constructor() {}
4509 export function LDKUnsignedGossipMessage_ty_from_ptr(ptr: bigint): number {
4510 if(!isWasmInitialized) {
4511 throw new Error("initializeWasm() must be awaited first!");
4513 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ty_from_ptr(ptr);
4514 return nativeResponseValue;
4517 export function LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr: bigint): bigint {
4518 if(!isWasmInitialized) {
4519 throw new Error("initializeWasm() must be awaited first!");
4521 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr);
4522 return nativeResponseValue;
4525 export function LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr: bigint): bigint {
4526 if(!isWasmInitialized) {
4527 throw new Error("initializeWasm() must be awaited first!");
4529 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr);
4530 return nativeResponseValue;
4533 export function LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr: bigint): bigint {
4534 if(!isWasmInitialized) {
4535 throw new Error("initializeWasm() must be awaited first!");
4537 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr);
4538 return nativeResponseValue;
4541 export interface LDKNodeSigner {
4542 get_inbound_payment_key_material (): number;
4543 get_node_id (recipient: Recipient): bigint;
4544 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
4545 sign_invoice (hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint;
4546 sign_bolt12_invoice_request (invoice_request: bigint): bigint;
4547 sign_bolt12_invoice (invoice: bigint): bigint;
4548 sign_gossip_message (msg: bigint): bigint;
4552 export function LDKNodeSigner_new(impl: LDKNodeSigner): [bigint, number] {
4553 if(!isWasmInitialized) {
4554 throw new Error("initializeWasm() must be awaited first!");
4556 var new_obj_idx = js_objs.length;
4557 for (var i = 0; i < js_objs.length; i++) {
4558 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4560 js_objs[i] = new WeakRef(impl);
4561 return [wasm.TS_LDKNodeSigner_new(i), i];
4563 // LDKThirtyTwoBytes NodeSigner_get_inbound_payment_key_material LDKNodeSigner *NONNULL_PTR this_arg
4565 export function NodeSigner_get_inbound_payment_key_material(this_arg: bigint): number {
4566 if(!isWasmInitialized) {
4567 throw new Error("initializeWasm() must be awaited first!");
4569 const nativeResponseValue = wasm.TS_NodeSigner_get_inbound_payment_key_material(this_arg);
4570 return nativeResponseValue;
4572 // LDKCResult_PublicKeyNoneZ NodeSigner_get_node_id LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient
4574 export function NodeSigner_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
4575 if(!isWasmInitialized) {
4576 throw new Error("initializeWasm() must be awaited first!");
4578 const nativeResponseValue = wasm.TS_NodeSigner_get_node_id(this_arg, recipient);
4579 return nativeResponseValue;
4581 // LDKCResult_ThirtyTwoBytesNoneZ NodeSigner_ecdh LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak
4583 export function NodeSigner_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
4584 if(!isWasmInitialized) {
4585 throw new Error("initializeWasm() must be awaited first!");
4587 const nativeResponseValue = wasm.TS_NodeSigner_ecdh(this_arg, recipient, other_key, tweak);
4588 return nativeResponseValue;
4590 // LDKCResult_RecoverableSignatureNoneZ NodeSigner_sign_invoice LDKNodeSigner *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient
4592 export function NodeSigner_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint {
4593 if(!isWasmInitialized) {
4594 throw new Error("initializeWasm() must be awaited first!");
4596 const nativeResponseValue = wasm.TS_NodeSigner_sign_invoice(this_arg, hrp_bytes, invoice_data, recipient);
4597 return nativeResponseValue;
4599 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice_request LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request
4601 export function NodeSigner_sign_bolt12_invoice_request(this_arg: bigint, invoice_request: bigint): bigint {
4602 if(!isWasmInitialized) {
4603 throw new Error("initializeWasm() must be awaited first!");
4605 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice_request(this_arg, invoice_request);
4606 return nativeResponseValue;
4608 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice
4610 export function NodeSigner_sign_bolt12_invoice(this_arg: bigint, invoice: bigint): bigint {
4611 if(!isWasmInitialized) {
4612 throw new Error("initializeWasm() must be awaited first!");
4614 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice(this_arg, invoice);
4615 return nativeResponseValue;
4617 // LDKCResult_ECDSASignatureNoneZ NodeSigner_sign_gossip_message LDKNodeSigner *NONNULL_PTR this_arg, struct LDKUnsignedGossipMessage msg
4619 export function NodeSigner_sign_gossip_message(this_arg: bigint, msg: bigint): bigint {
4620 if(!isWasmInitialized) {
4621 throw new Error("initializeWasm() must be awaited first!");
4623 const nativeResponseValue = wasm.TS_NodeSigner_sign_gossip_message(this_arg, msg);
4624 return nativeResponseValue;
4627 export interface LDKSignerProvider {
4628 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
4629 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
4630 read_chan_signer (reader: number): bigint;
4631 get_destination_script (): bigint;
4632 get_shutdown_scriptpubkey (): bigint;
4636 export function LDKSignerProvider_new(impl: LDKSignerProvider): [bigint, number] {
4637 if(!isWasmInitialized) {
4638 throw new Error("initializeWasm() must be awaited first!");
4640 var new_obj_idx = js_objs.length;
4641 for (var i = 0; i < js_objs.length; i++) {
4642 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4644 js_objs[i] = new WeakRef(impl);
4645 return [wasm.TS_LDKSignerProvider_new(i), i];
4647 // LDKThirtyTwoBytes SignerProvider_generate_channel_keys_id LDKSignerProvider *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
4649 export function SignerProvider_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
4650 if(!isWasmInitialized) {
4651 throw new Error("initializeWasm() must be awaited first!");
4653 const nativeResponseValue = wasm.TS_SignerProvider_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
4654 return nativeResponseValue;
4656 // LDKWriteableEcdsaChannelSigner SignerProvider_derive_channel_signer LDKSignerProvider *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
4658 export function SignerProvider_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
4659 if(!isWasmInitialized) {
4660 throw new Error("initializeWasm() must be awaited first!");
4662 const nativeResponseValue = wasm.TS_SignerProvider_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
4663 return nativeResponseValue;
4665 // LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider_read_chan_signer LDKSignerProvider *NONNULL_PTR this_arg, struct LDKu8slice reader
4667 export function SignerProvider_read_chan_signer(this_arg: bigint, reader: number): bigint {
4668 if(!isWasmInitialized) {
4669 throw new Error("initializeWasm() must be awaited first!");
4671 const nativeResponseValue = wasm.TS_SignerProvider_read_chan_signer(this_arg, reader);
4672 return nativeResponseValue;
4674 // LDKCResult_CVec_u8ZNoneZ SignerProvider_get_destination_script LDKSignerProvider *NONNULL_PTR this_arg
4676 export function SignerProvider_get_destination_script(this_arg: bigint): bigint {
4677 if(!isWasmInitialized) {
4678 throw new Error("initializeWasm() must be awaited first!");
4680 const nativeResponseValue = wasm.TS_SignerProvider_get_destination_script(this_arg);
4681 return nativeResponseValue;
4683 // LDKCResult_ShutdownScriptNoneZ SignerProvider_get_shutdown_scriptpubkey LDKSignerProvider *NONNULL_PTR this_arg
4685 export function SignerProvider_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4686 if(!isWasmInitialized) {
4687 throw new Error("initializeWasm() must be awaited first!");
4689 const nativeResponseValue = wasm.TS_SignerProvider_get_shutdown_scriptpubkey(this_arg);
4690 return nativeResponseValue;
4693 export interface LDKFeeEstimator {
4694 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4698 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
4699 if(!isWasmInitialized) {
4700 throw new Error("initializeWasm() must be awaited first!");
4702 var new_obj_idx = js_objs.length;
4703 for (var i = 0; i < js_objs.length; i++) {
4704 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4706 js_objs[i] = new WeakRef(impl);
4707 return [wasm.TS_LDKFeeEstimator_new(i), i];
4709 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4711 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4712 if(!isWasmInitialized) {
4713 throw new Error("initializeWasm() must be awaited first!");
4715 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4716 return nativeResponseValue;
4719 export interface LDKRouter {
4720 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
4721 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
4725 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
4726 if(!isWasmInitialized) {
4727 throw new Error("initializeWasm() must be awaited first!");
4729 var new_obj_idx = js_objs.length;
4730 for (var i = 0; i < js_objs.length; i++) {
4731 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4733 js_objs[i] = new WeakRef(impl);
4734 return [wasm.TS_LDKRouter_new(i), i];
4736 // 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
4738 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
4739 if(!isWasmInitialized) {
4740 throw new Error("initializeWasm() must be awaited first!");
4742 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
4743 return nativeResponseValue;
4745 // 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
4747 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 {
4748 if(!isWasmInitialized) {
4749 throw new Error("initializeWasm() must be awaited first!");
4751 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
4752 return nativeResponseValue;
4754 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
4756 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner: bigint): number {
4757 if(!isWasmInitialized) {
4758 throw new Error("initializeWasm() must be awaited first!");
4760 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner);
4761 return nativeResponseValue;
4763 // struct LDKChannelManager C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
4765 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner: bigint): bigint {
4766 if(!isWasmInitialized) {
4767 throw new Error("initializeWasm() must be awaited first!");
4769 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner);
4770 return nativeResponseValue;
4772 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4774 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
4775 if(!isWasmInitialized) {
4776 throw new Error("initializeWasm() must be awaited first!");
4778 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner);
4779 return nativeResponseValue;
4781 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4783 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
4784 if(!isWasmInitialized) {
4785 throw new Error("initializeWasm() must be awaited first!");
4787 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner);
4788 return nativeResponseValue;
4791 export class LDKMaxDustHTLCExposure {
4792 protected constructor() {}
4795 export function LDKMaxDustHTLCExposure_ty_from_ptr(ptr: bigint): number {
4796 if(!isWasmInitialized) {
4797 throw new Error("initializeWasm() must be awaited first!");
4799 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_ty_from_ptr(ptr);
4800 return nativeResponseValue;
4803 export function LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr: bigint): bigint {
4804 if(!isWasmInitialized) {
4805 throw new Error("initializeWasm() must be awaited first!");
4807 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr);
4808 return nativeResponseValue;
4811 export function LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr: bigint): bigint {
4812 if(!isWasmInitialized) {
4813 throw new Error("initializeWasm() must be awaited first!");
4815 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr);
4816 return nativeResponseValue;
4818 // struct LDKMaxDustHTLCExposure CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
4820 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner: bigint): bigint {
4821 if(!isWasmInitialized) {
4822 throw new Error("initializeWasm() must be awaited first!");
4824 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner);
4825 return nativeResponseValue;
4827 // struct LDKDecodeError CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
4829 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner: bigint): bigint {
4830 if(!isWasmInitialized) {
4831 throw new Error("initializeWasm() must be awaited first!");
4833 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner);
4834 return nativeResponseValue;
4836 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4838 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
4839 if(!isWasmInitialized) {
4840 throw new Error("initializeWasm() must be awaited first!");
4842 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4843 return nativeResponseValue;
4845 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4847 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
4848 if(!isWasmInitialized) {
4849 throw new Error("initializeWasm() must be awaited first!");
4851 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4852 return nativeResponseValue;
4855 export class LDKCOption_MaxDustHTLCExposureZ {
4856 protected constructor() {}
4859 export function LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr: bigint): number {
4860 if(!isWasmInitialized) {
4861 throw new Error("initializeWasm() must be awaited first!");
4863 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr);
4864 return nativeResponseValue;
4867 export function LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr: bigint): bigint {
4868 if(!isWasmInitialized) {
4869 throw new Error("initializeWasm() must be awaited first!");
4871 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr);
4872 return nativeResponseValue;
4875 export class LDKCOption_APIErrorZ {
4876 protected constructor() {}
4879 export function LDKCOption_APIErrorZ_ty_from_ptr(ptr: bigint): number {
4880 if(!isWasmInitialized) {
4881 throw new Error("initializeWasm() must be awaited first!");
4883 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_ty_from_ptr(ptr);
4884 return nativeResponseValue;
4887 export function LDKCOption_APIErrorZ_Some_get_some(ptr: bigint): bigint {
4888 if(!isWasmInitialized) {
4889 throw new Error("initializeWasm() must be awaited first!");
4891 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_Some_get_some(ptr);
4892 return nativeResponseValue;
4894 // struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
4896 export function CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner: bigint): bigint {
4897 if(!isWasmInitialized) {
4898 throw new Error("initializeWasm() must be awaited first!");
4900 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner);
4901 return nativeResponseValue;
4903 // struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
4905 export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bigint {
4906 if(!isWasmInitialized) {
4907 throw new Error("initializeWasm() must be awaited first!");
4909 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
4910 return nativeResponseValue;
4912 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4914 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4915 if(!isWasmInitialized) {
4916 throw new Error("initializeWasm() must be awaited first!");
4918 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4919 return nativeResponseValue;
4921 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4923 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4924 if(!isWasmInitialized) {
4925 throw new Error("initializeWasm() must be awaited first!");
4927 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4928 return nativeResponseValue;
4931 export class LDKCOption_MonitorEventZ {
4932 protected constructor() {}
4935 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
4936 if(!isWasmInitialized) {
4937 throw new Error("initializeWasm() must be awaited first!");
4939 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4940 return nativeResponseValue;
4943 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
4944 if(!isWasmInitialized) {
4945 throw new Error("initializeWasm() must be awaited first!");
4947 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4948 return nativeResponseValue;
4950 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4952 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
4953 if(!isWasmInitialized) {
4954 throw new Error("initializeWasm() must be awaited first!");
4956 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4957 return nativeResponseValue;
4959 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4961 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
4962 if(!isWasmInitialized) {
4963 throw new Error("initializeWasm() must be awaited first!");
4965 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4966 return nativeResponseValue;
4968 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4970 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4971 if(!isWasmInitialized) {
4972 throw new Error("initializeWasm() must be awaited first!");
4974 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4975 return nativeResponseValue;
4977 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4979 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4980 if(!isWasmInitialized) {
4981 throw new Error("initializeWasm() must be awaited first!");
4983 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4984 return nativeResponseValue;
4986 // struct LDKOutPoint C2Tuple_OutPointCVec_u8ZZ_get_a(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
4988 export function C2Tuple_OutPointCVec_u8ZZ_get_a(owner: bigint): bigint {
4989 if(!isWasmInitialized) {
4990 throw new Error("initializeWasm() must be awaited first!");
4992 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_a(owner);
4993 return nativeResponseValue;
4995 // struct LDKCVec_u8Z C2Tuple_OutPointCVec_u8ZZ_get_b(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
4997 export function C2Tuple_OutPointCVec_u8ZZ_get_b(owner: bigint): number {
4998 if(!isWasmInitialized) {
4999 throw new Error("initializeWasm() must be awaited first!");
5001 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_b(owner);
5002 return nativeResponseValue;
5004 // uint32_t C2Tuple_u32CVec_u8ZZ_get_a(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
5006 export function C2Tuple_u32CVec_u8ZZ_get_a(owner: bigint): number {
5007 if(!isWasmInitialized) {
5008 throw new Error("initializeWasm() must be awaited first!");
5010 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_a(owner);
5011 return nativeResponseValue;
5013 // struct LDKCVec_u8Z C2Tuple_u32CVec_u8ZZ_get_b(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
5015 export function C2Tuple_u32CVec_u8ZZ_get_b(owner: bigint): number {
5016 if(!isWasmInitialized) {
5017 throw new Error("initializeWasm() must be awaited first!");
5019 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_b(owner);
5020 return nativeResponseValue;
5022 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
5024 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner: bigint): number {
5025 if(!isWasmInitialized) {
5026 throw new Error("initializeWasm() must be awaited first!");
5028 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner);
5029 return nativeResponseValue;
5031 // struct LDKCVec_C2Tuple_u32CVec_u8ZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
5033 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner: bigint): number {
5034 if(!isWasmInitialized) {
5035 throw new Error("initializeWasm() must be awaited first!");
5037 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner);
5038 return nativeResponseValue;
5040 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5042 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
5043 if(!isWasmInitialized) {
5044 throw new Error("initializeWasm() must be awaited first!");
5046 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
5047 return nativeResponseValue;
5049 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5051 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
5052 if(!isWasmInitialized) {
5053 throw new Error("initializeWasm() must be awaited first!");
5055 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
5056 return nativeResponseValue;
5058 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5060 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
5061 if(!isWasmInitialized) {
5062 throw new Error("initializeWasm() must be awaited first!");
5064 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
5065 return nativeResponseValue;
5067 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5069 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
5070 if(!isWasmInitialized) {
5071 throw new Error("initializeWasm() must be awaited first!");
5073 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
5074 return nativeResponseValue;
5077 export class LDKBalance {
5078 protected constructor() {}
5081 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
5082 if(!isWasmInitialized) {
5083 throw new Error("initializeWasm() must be awaited first!");
5085 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
5086 return nativeResponseValue;
5089 export function LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr: bigint): bigint {
5090 if(!isWasmInitialized) {
5091 throw new Error("initializeWasm() must be awaited first!");
5093 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr);
5094 return nativeResponseValue;
5097 export function LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr: bigint): bigint {
5098 if(!isWasmInitialized) {
5099 throw new Error("initializeWasm() must be awaited first!");
5101 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr);
5102 return nativeResponseValue;
5105 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
5106 if(!isWasmInitialized) {
5107 throw new Error("initializeWasm() must be awaited first!");
5109 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
5110 return nativeResponseValue;
5113 export function LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr: bigint): bigint {
5114 if(!isWasmInitialized) {
5115 throw new Error("initializeWasm() must be awaited first!");
5117 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr);
5118 return nativeResponseValue;
5121 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
5122 if(!isWasmInitialized) {
5123 throw new Error("initializeWasm() must be awaited first!");
5125 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
5126 return nativeResponseValue;
5129 export function LDKBalance_ContentiousClaimable_get_payment_hash(ptr: bigint): number {
5130 if(!isWasmInitialized) {
5131 throw new Error("initializeWasm() must be awaited first!");
5133 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_hash(ptr);
5134 return nativeResponseValue;
5137 export function LDKBalance_ContentiousClaimable_get_payment_preimage(ptr: bigint): number {
5138 if(!isWasmInitialized) {
5139 throw new Error("initializeWasm() must be awaited first!");
5141 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_preimage(ptr);
5142 return nativeResponseValue;
5145 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
5146 if(!isWasmInitialized) {
5147 throw new Error("initializeWasm() must be awaited first!");
5149 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr);
5150 return nativeResponseValue;
5153 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5154 if(!isWasmInitialized) {
5155 throw new Error("initializeWasm() must be awaited first!");
5157 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5158 return nativeResponseValue;
5161 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr: bigint): number {
5162 if(!isWasmInitialized) {
5163 throw new Error("initializeWasm() must be awaited first!");
5165 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr);
5166 return nativeResponseValue;
5169 export function LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
5170 if(!isWasmInitialized) {
5171 throw new Error("initializeWasm() must be awaited first!");
5173 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr);
5174 return nativeResponseValue;
5177 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5178 if(!isWasmInitialized) {
5179 throw new Error("initializeWasm() must be awaited first!");
5181 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5182 return nativeResponseValue;
5185 export function LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr: bigint): number {
5186 if(!isWasmInitialized) {
5187 throw new Error("initializeWasm() must be awaited first!");
5189 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr);
5190 return nativeResponseValue;
5193 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr: bigint): bigint {
5194 if(!isWasmInitialized) {
5195 throw new Error("initializeWasm() must be awaited first!");
5197 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr);
5198 return nativeResponseValue;
5200 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
5202 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner: bigint): number {
5203 if(!isWasmInitialized) {
5204 throw new Error("initializeWasm() must be awaited first!");
5206 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner);
5207 return nativeResponseValue;
5209 // struct LDKChannelMonitor C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
5211 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner: bigint): bigint {
5212 if(!isWasmInitialized) {
5213 throw new Error("initializeWasm() must be awaited first!");
5215 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner);
5216 return nativeResponseValue;
5218 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5220 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5221 if(!isWasmInitialized) {
5222 throw new Error("initializeWasm() must be awaited first!");
5224 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner);
5225 return nativeResponseValue;
5227 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5229 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5230 if(!isWasmInitialized) {
5231 throw new Error("initializeWasm() must be awaited first!");
5233 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner);
5234 return nativeResponseValue;
5237 export interface LDKType {
5239 debug_str (): number;
5244 export function LDKType_new(impl: LDKType): [bigint, number] {
5245 if(!isWasmInitialized) {
5246 throw new Error("initializeWasm() must be awaited first!");
5248 var new_obj_idx = js_objs.length;
5249 for (var i = 0; i < js_objs.length; i++) {
5250 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5252 js_objs[i] = new WeakRef(impl);
5253 return [wasm.TS_LDKType_new(i), i];
5255 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
5257 export function Type_type_id(this_arg: bigint): number {
5258 if(!isWasmInitialized) {
5259 throw new Error("initializeWasm() must be awaited first!");
5261 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
5262 return nativeResponseValue;
5264 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
5266 export function Type_debug_str(this_arg: bigint): number {
5267 if(!isWasmInitialized) {
5268 throw new Error("initializeWasm() must be awaited first!");
5270 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
5271 return nativeResponseValue;
5273 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
5275 export function Type_write(this_arg: bigint): number {
5276 if(!isWasmInitialized) {
5277 throw new Error("initializeWasm() must be awaited first!");
5279 const nativeResponseValue = wasm.TS_Type_write(this_arg);
5280 return nativeResponseValue;
5282 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5284 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5285 if(!isWasmInitialized) {
5286 throw new Error("initializeWasm() must be awaited first!");
5288 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5289 return nativeResponseValue;
5291 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5293 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5294 if(!isWasmInitialized) {
5295 throw new Error("initializeWasm() must be awaited first!");
5297 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5298 return nativeResponseValue;
5301 export class LDKOffersMessage {
5302 protected constructor() {}
5305 export function LDKOffersMessage_ty_from_ptr(ptr: bigint): number {
5306 if(!isWasmInitialized) {
5307 throw new Error("initializeWasm() must be awaited first!");
5309 const nativeResponseValue = wasm.TS_LDKOffersMessage_ty_from_ptr(ptr);
5310 return nativeResponseValue;
5313 export function LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr: bigint): bigint {
5314 if(!isWasmInitialized) {
5315 throw new Error("initializeWasm() must be awaited first!");
5317 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr);
5318 return nativeResponseValue;
5321 export function LDKOffersMessage_Invoice_get_invoice(ptr: bigint): bigint {
5322 if(!isWasmInitialized) {
5323 throw new Error("initializeWasm() must be awaited first!");
5325 const nativeResponseValue = wasm.TS_LDKOffersMessage_Invoice_get_invoice(ptr);
5326 return nativeResponseValue;
5329 export function LDKOffersMessage_InvoiceError_get_invoice_error(ptr: bigint): bigint {
5330 if(!isWasmInitialized) {
5331 throw new Error("initializeWasm() must be awaited first!");
5333 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceError_get_invoice_error(ptr);
5334 return nativeResponseValue;
5337 export class LDKCOption_OffersMessageZ {
5338 protected constructor() {}
5341 export function LDKCOption_OffersMessageZ_ty_from_ptr(ptr: bigint): number {
5342 if(!isWasmInitialized) {
5343 throw new Error("initializeWasm() must be awaited first!");
5345 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_ty_from_ptr(ptr);
5346 return nativeResponseValue;
5349 export function LDKCOption_OffersMessageZ_Some_get_some(ptr: bigint): bigint {
5350 if(!isWasmInitialized) {
5351 throw new Error("initializeWasm() must be awaited first!");
5353 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_Some_get_some(ptr);
5354 return nativeResponseValue;
5357 export interface LDKCustomOnionMessageContents {
5358 tlv_type (): bigint;
5363 export function LDKCustomOnionMessageContents_new(impl: LDKCustomOnionMessageContents): [bigint, number] {
5364 if(!isWasmInitialized) {
5365 throw new Error("initializeWasm() must be awaited first!");
5367 var new_obj_idx = js_objs.length;
5368 for (var i = 0; i < js_objs.length; i++) {
5369 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5371 js_objs[i] = new WeakRef(impl);
5372 return [wasm.TS_LDKCustomOnionMessageContents_new(i), i];
5374 // uint64_t CustomOnionMessageContents_tlv_type LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5376 export function CustomOnionMessageContents_tlv_type(this_arg: bigint): bigint {
5377 if(!isWasmInitialized) {
5378 throw new Error("initializeWasm() must be awaited first!");
5380 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_tlv_type(this_arg);
5381 return nativeResponseValue;
5383 // LDKCVec_u8Z CustomOnionMessageContents_write LDKCustomOnionMessageContents *NONNULL_PTR this_arg
5385 export function CustomOnionMessageContents_write(this_arg: bigint): number {
5386 if(!isWasmInitialized) {
5387 throw new Error("initializeWasm() must be awaited first!");
5389 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_write(this_arg);
5390 return nativeResponseValue;
5393 export class LDKCOption_CustomOnionMessageContentsZ {
5394 protected constructor() {}
5397 export function LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
5398 if(!isWasmInitialized) {
5399 throw new Error("initializeWasm() must be awaited first!");
5401 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(ptr);
5402 return nativeResponseValue;
5405 export function LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(ptr);
5410 return nativeResponseValue;
5412 // struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5414 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner);
5419 return nativeResponseValue;
5421 // struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5423 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner);
5428 return nativeResponseValue;
5431 export class LDKCOption_TypeZ {
5432 protected constructor() {}
5435 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
5436 if(!isWasmInitialized) {
5437 throw new Error("initializeWasm() must be awaited first!");
5439 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
5440 return nativeResponseValue;
5443 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
5444 if(!isWasmInitialized) {
5445 throw new Error("initializeWasm() must be awaited first!");
5447 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
5448 return nativeResponseValue;
5450 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
5452 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
5453 if(!isWasmInitialized) {
5454 throw new Error("initializeWasm() must be awaited first!");
5456 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
5457 return nativeResponseValue;
5459 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
5461 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
5462 if(!isWasmInitialized) {
5463 throw new Error("initializeWasm() must be awaited first!");
5465 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
5466 return nativeResponseValue;
5469 export class LDKCOption_SocketAddressZ {
5470 protected constructor() {}
5473 export function LDKCOption_SocketAddressZ_ty_from_ptr(ptr: bigint): number {
5474 if(!isWasmInitialized) {
5475 throw new Error("initializeWasm() must be awaited first!");
5477 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_ty_from_ptr(ptr);
5478 return nativeResponseValue;
5481 export function LDKCOption_SocketAddressZ_Some_get_some(ptr: bigint): bigint {
5482 if(!isWasmInitialized) {
5483 throw new Error("initializeWasm() must be awaited first!");
5485 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_Some_get_some(ptr);
5486 return nativeResponseValue;
5488 // struct LDKPublicKey C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner);
5490 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner: bigint): number {
5491 if(!isWasmInitialized) {
5492 throw new Error("initializeWasm() must be awaited first!");
5494 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner);
5495 return nativeResponseValue;
5497 // struct LDKCOption_SocketAddressZ C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner);
5499 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner: bigint): bigint {
5500 if(!isWasmInitialized) {
5501 throw new Error("initializeWasm() must be awaited first!");
5503 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner);
5504 return nativeResponseValue;
5506 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5508 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
5509 if(!isWasmInitialized) {
5510 throw new Error("initializeWasm() must be awaited first!");
5512 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
5513 return nativeResponseValue;
5515 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5517 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
5518 if(!isWasmInitialized) {
5519 throw new Error("initializeWasm() must be awaited first!");
5521 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
5522 return nativeResponseValue;
5524 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5526 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
5527 if(!isWasmInitialized) {
5528 throw new Error("initializeWasm() must be awaited first!");
5530 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
5531 // debug statements here
5533 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5535 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
5536 if(!isWasmInitialized) {
5537 throw new Error("initializeWasm() must be awaited first!");
5539 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
5540 return nativeResponseValue;
5542 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5544 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
5545 if(!isWasmInitialized) {
5546 throw new Error("initializeWasm() must be awaited first!");
5548 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
5549 return nativeResponseValue;
5551 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5553 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
5554 if(!isWasmInitialized) {
5555 throw new Error("initializeWasm() must be awaited first!");
5557 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
5558 return nativeResponseValue;
5561 export class LDKGraphSyncError {
5562 protected constructor() {}
5565 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
5566 if(!isWasmInitialized) {
5567 throw new Error("initializeWasm() must be awaited first!");
5569 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
5570 return nativeResponseValue;
5573 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
5574 if(!isWasmInitialized) {
5575 throw new Error("initializeWasm() must be awaited first!");
5577 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
5578 return nativeResponseValue;
5581 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
5582 if(!isWasmInitialized) {
5583 throw new Error("initializeWasm() must be awaited first!");
5585 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
5586 return nativeResponseValue;
5588 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5590 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
5591 if(!isWasmInitialized) {
5592 throw new Error("initializeWasm() must be awaited first!");
5594 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
5595 return nativeResponseValue;
5597 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5599 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
5600 if(!isWasmInitialized) {
5601 throw new Error("initializeWasm() must be awaited first!");
5603 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
5604 return nativeResponseValue;
5606 // struct LDKCVec_u8Z CResult_CVec_u8ZIOErrorZ_get_ok(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
5608 export function CResult_CVec_u8ZIOErrorZ_get_ok(owner: bigint): number {
5609 if(!isWasmInitialized) {
5610 throw new Error("initializeWasm() must be awaited first!");
5612 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_ok(owner);
5613 return nativeResponseValue;
5615 // enum LDKIOError CResult_CVec_u8ZIOErrorZ_get_err(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
5617 export function CResult_CVec_u8ZIOErrorZ_get_err(owner: bigint): IOError {
5618 if(!isWasmInitialized) {
5619 throw new Error("initializeWasm() must be awaited first!");
5621 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_err(owner);
5622 return nativeResponseValue;
5624 // void CResult_NoneIOErrorZ_get_ok(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
5626 export function CResult_NoneIOErrorZ_get_ok(owner: bigint): void {
5627 if(!isWasmInitialized) {
5628 throw new Error("initializeWasm() must be awaited first!");
5630 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_ok(owner);
5631 // debug statements here
5633 // enum LDKIOError CResult_NoneIOErrorZ_get_err(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
5635 export function CResult_NoneIOErrorZ_get_err(owner: bigint): IOError {
5636 if(!isWasmInitialized) {
5637 throw new Error("initializeWasm() must be awaited first!");
5639 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_err(owner);
5640 return nativeResponseValue;
5642 // struct LDKCVec_StrZ CResult_CVec_StrZIOErrorZ_get_ok(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
5644 export function CResult_CVec_StrZIOErrorZ_get_ok(owner: bigint): number {
5645 if(!isWasmInitialized) {
5646 throw new Error("initializeWasm() must be awaited first!");
5648 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_ok(owner);
5649 return nativeResponseValue;
5651 // enum LDKIOError CResult_CVec_StrZIOErrorZ_get_err(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
5653 export function CResult_CVec_StrZIOErrorZ_get_err(owner: bigint): IOError {
5654 if(!isWasmInitialized) {
5655 throw new Error("initializeWasm() must be awaited first!");
5657 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_err(owner);
5658 return nativeResponseValue;
5660 // struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
5662 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner: bigint): number {
5663 if(!isWasmInitialized) {
5664 throw new Error("initializeWasm() must be awaited first!");
5666 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner);
5667 return nativeResponseValue;
5669 // enum LDKIOError CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
5671 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner: bigint): IOError {
5672 if(!isWasmInitialized) {
5673 throw new Error("initializeWasm() must be awaited first!");
5675 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner);
5676 return nativeResponseValue;
5678 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
5680 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner: bigint): bigint {
5681 if(!isWasmInitialized) {
5682 throw new Error("initializeWasm() must be awaited first!");
5684 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner);
5685 return nativeResponseValue;
5687 // enum LDKIOError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
5689 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner: bigint): IOError {
5690 if(!isWasmInitialized) {
5691 throw new Error("initializeWasm() must be awaited first!");
5693 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner);
5694 return nativeResponseValue;
5697 export class LDKCOption_SecretKeyZ {
5698 protected constructor() {}
5701 export function LDKCOption_SecretKeyZ_ty_from_ptr(ptr: bigint): number {
5702 if(!isWasmInitialized) {
5703 throw new Error("initializeWasm() must be awaited first!");
5705 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_ty_from_ptr(ptr);
5706 return nativeResponseValue;
5709 export function LDKCOption_SecretKeyZ_Some_get_some(ptr: bigint): number {
5710 if(!isWasmInitialized) {
5711 throw new Error("initializeWasm() must be awaited first!");
5713 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_Some_get_some(ptr);
5714 return nativeResponseValue;
5716 // struct LDKVerifiedInvoiceRequest CResult_VerifiedInvoiceRequestNoneZ_get_ok(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
5718 export function CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner: bigint): bigint {
5719 if(!isWasmInitialized) {
5720 throw new Error("initializeWasm() must be awaited first!");
5722 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner);
5723 return nativeResponseValue;
5725 // void CResult_VerifiedInvoiceRequestNoneZ_get_err(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
5727 export function CResult_VerifiedInvoiceRequestNoneZ_get_err(owner: bigint): void {
5728 if(!isWasmInitialized) {
5729 throw new Error("initializeWasm() must be awaited first!");
5731 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_err(owner);
5732 // debug statements here
5735 export class LDKCOption_i64Z {
5736 protected constructor() {}
5739 export function LDKCOption_i64Z_ty_from_ptr(ptr: bigint): number {
5740 if(!isWasmInitialized) {
5741 throw new Error("initializeWasm() must be awaited first!");
5743 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_ty_from_ptr(ptr);
5744 return nativeResponseValue;
5747 export function LDKCOption_i64Z_Some_get_some(ptr: bigint): bigint {
5748 if(!isWasmInitialized) {
5749 throw new Error("initializeWasm() must be awaited first!");
5751 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_Some_get_some(ptr);
5752 return nativeResponseValue;
5754 // struct LDKSocketAddress CResult_SocketAddressDecodeErrorZ_get_ok(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
5756 export function CResult_SocketAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
5757 if(!isWasmInitialized) {
5758 throw new Error("initializeWasm() must be awaited first!");
5760 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_ok(owner);
5761 return nativeResponseValue;
5763 // struct LDKDecodeError CResult_SocketAddressDecodeErrorZ_get_err(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
5765 export function CResult_SocketAddressDecodeErrorZ_get_err(owner: bigint): bigint {
5766 if(!isWasmInitialized) {
5767 throw new Error("initializeWasm() must be awaited first!");
5769 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_err(owner);
5770 return nativeResponseValue;
5772 // struct LDKSocketAddress CResult_SocketAddressSocketAddressParseErrorZ_get_ok(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
5774 export function CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner: bigint): bigint {
5775 if(!isWasmInitialized) {
5776 throw new Error("initializeWasm() must be awaited first!");
5778 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner);
5779 return nativeResponseValue;
5781 // enum LDKSocketAddressParseError CResult_SocketAddressSocketAddressParseErrorZ_get_err(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
5783 export function CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner: bigint): SocketAddressParseError {
5784 if(!isWasmInitialized) {
5785 throw new Error("initializeWasm() must be awaited first!");
5787 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner);
5788 return nativeResponseValue;
5790 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5792 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5793 if(!isWasmInitialized) {
5794 throw new Error("initializeWasm() must be awaited first!");
5796 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5797 return nativeResponseValue;
5799 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5801 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5806 return nativeResponseValue;
5808 // struct LDKAcceptChannelV2 CResult_AcceptChannelV2DecodeErrorZ_get_ok(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
5810 export function CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner);
5815 return nativeResponseValue;
5817 // struct LDKDecodeError CResult_AcceptChannelV2DecodeErrorZ_get_err(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
5819 export function CResult_AcceptChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
5820 if(!isWasmInitialized) {
5821 throw new Error("initializeWasm() must be awaited first!");
5823 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_err(owner);
5824 return nativeResponseValue;
5826 // struct LDKTxAddInput CResult_TxAddInputDecodeErrorZ_get_ok(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
5828 export function CResult_TxAddInputDecodeErrorZ_get_ok(owner: bigint): bigint {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_ok(owner);
5833 return nativeResponseValue;
5835 // struct LDKDecodeError CResult_TxAddInputDecodeErrorZ_get_err(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
5837 export function CResult_TxAddInputDecodeErrorZ_get_err(owner: bigint): bigint {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_err(owner);
5842 return nativeResponseValue;
5844 // struct LDKTxAddOutput CResult_TxAddOutputDecodeErrorZ_get_ok(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
5846 export function CResult_TxAddOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_ok(owner);
5851 return nativeResponseValue;
5853 // struct LDKDecodeError CResult_TxAddOutputDecodeErrorZ_get_err(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
5855 export function CResult_TxAddOutputDecodeErrorZ_get_err(owner: bigint): bigint {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_err(owner);
5860 return nativeResponseValue;
5862 // struct LDKTxRemoveInput CResult_TxRemoveInputDecodeErrorZ_get_ok(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
5864 export function CResult_TxRemoveInputDecodeErrorZ_get_ok(owner: bigint): bigint {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_ok(owner);
5869 return nativeResponseValue;
5871 // struct LDKDecodeError CResult_TxRemoveInputDecodeErrorZ_get_err(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
5873 export function CResult_TxRemoveInputDecodeErrorZ_get_err(owner: bigint): bigint {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_err(owner);
5878 return nativeResponseValue;
5880 // struct LDKTxRemoveOutput CResult_TxRemoveOutputDecodeErrorZ_get_ok(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
5882 export function CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner);
5887 return nativeResponseValue;
5889 // struct LDKDecodeError CResult_TxRemoveOutputDecodeErrorZ_get_err(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
5891 export function CResult_TxRemoveOutputDecodeErrorZ_get_err(owner: bigint): bigint {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_err(owner);
5896 return nativeResponseValue;
5898 // struct LDKTxComplete CResult_TxCompleteDecodeErrorZ_get_ok(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
5900 export function CResult_TxCompleteDecodeErrorZ_get_ok(owner: bigint): bigint {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_ok(owner);
5905 return nativeResponseValue;
5907 // struct LDKDecodeError CResult_TxCompleteDecodeErrorZ_get_err(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
5909 export function CResult_TxCompleteDecodeErrorZ_get_err(owner: bigint): bigint {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_err(owner);
5914 return nativeResponseValue;
5916 // struct LDKTxSignatures CResult_TxSignaturesDecodeErrorZ_get_ok(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
5918 export function CResult_TxSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_ok(owner);
5923 return nativeResponseValue;
5925 // struct LDKDecodeError CResult_TxSignaturesDecodeErrorZ_get_err(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
5927 export function CResult_TxSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_err(owner);
5932 return nativeResponseValue;
5934 // struct LDKTxInitRbf CResult_TxInitRbfDecodeErrorZ_get_ok(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
5936 export function CResult_TxInitRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_ok(owner);
5941 return nativeResponseValue;
5943 // struct LDKDecodeError CResult_TxInitRbfDecodeErrorZ_get_err(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
5945 export function CResult_TxInitRbfDecodeErrorZ_get_err(owner: bigint): bigint {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_err(owner);
5950 return nativeResponseValue;
5952 // struct LDKTxAckRbf CResult_TxAckRbfDecodeErrorZ_get_ok(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
5954 export function CResult_TxAckRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_ok(owner);
5959 return nativeResponseValue;
5961 // struct LDKDecodeError CResult_TxAckRbfDecodeErrorZ_get_err(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
5963 export function CResult_TxAckRbfDecodeErrorZ_get_err(owner: bigint): bigint {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_err(owner);
5968 return nativeResponseValue;
5970 // struct LDKTxAbort CResult_TxAbortDecodeErrorZ_get_ok(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
5972 export function CResult_TxAbortDecodeErrorZ_get_ok(owner: bigint): bigint {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_ok(owner);
5977 return nativeResponseValue;
5979 // struct LDKDecodeError CResult_TxAbortDecodeErrorZ_get_err(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
5981 export function CResult_TxAbortDecodeErrorZ_get_err(owner: bigint): bigint {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_err(owner);
5986 return nativeResponseValue;
5988 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5990 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5995 return nativeResponseValue;
5997 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5999 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
6004 return nativeResponseValue;
6006 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6008 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
6013 return nativeResponseValue;
6015 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6017 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
6022 return nativeResponseValue;
6024 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6026 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
6031 return nativeResponseValue;
6033 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6035 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
6040 return nativeResponseValue;
6042 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6044 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
6049 return nativeResponseValue;
6051 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6053 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
6058 return nativeResponseValue;
6060 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6062 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6063 if(!isWasmInitialized) {
6064 throw new Error("initializeWasm() must be awaited first!");
6066 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
6067 return nativeResponseValue;
6069 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6071 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
6076 return nativeResponseValue;
6078 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6080 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
6081 if(!isWasmInitialized) {
6082 throw new Error("initializeWasm() must be awaited first!");
6084 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
6085 return nativeResponseValue;
6087 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6089 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
6094 return nativeResponseValue;
6096 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6098 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6099 if(!isWasmInitialized) {
6100 throw new Error("initializeWasm() must be awaited first!");
6102 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
6103 return nativeResponseValue;
6105 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6107 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
6112 return nativeResponseValue;
6114 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6116 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
6117 if(!isWasmInitialized) {
6118 throw new Error("initializeWasm() must be awaited first!");
6120 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
6121 return nativeResponseValue;
6123 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6125 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
6130 return nativeResponseValue;
6132 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6134 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
6135 if(!isWasmInitialized) {
6136 throw new Error("initializeWasm() must be awaited first!");
6138 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
6139 return nativeResponseValue;
6141 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6143 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
6144 if(!isWasmInitialized) {
6145 throw new Error("initializeWasm() must be awaited first!");
6147 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
6148 return nativeResponseValue;
6150 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6152 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6153 if(!isWasmInitialized) {
6154 throw new Error("initializeWasm() must be awaited first!");
6156 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
6157 return nativeResponseValue;
6159 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6161 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6162 if(!isWasmInitialized) {
6163 throw new Error("initializeWasm() must be awaited first!");
6165 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
6166 return nativeResponseValue;
6168 // struct LDKOpenChannelV2 CResult_OpenChannelV2DecodeErrorZ_get_ok(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
6170 export function CResult_OpenChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
6171 if(!isWasmInitialized) {
6172 throw new Error("initializeWasm() must be awaited first!");
6174 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_ok(owner);
6175 return nativeResponseValue;
6177 // struct LDKDecodeError CResult_OpenChannelV2DecodeErrorZ_get_err(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
6179 export function CResult_OpenChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
6180 if(!isWasmInitialized) {
6181 throw new Error("initializeWasm() must be awaited first!");
6183 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_err(owner);
6184 return nativeResponseValue;
6186 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6188 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
6189 if(!isWasmInitialized) {
6190 throw new Error("initializeWasm() must be awaited first!");
6192 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
6193 return nativeResponseValue;
6195 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6197 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
6198 if(!isWasmInitialized) {
6199 throw new Error("initializeWasm() must be awaited first!");
6201 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
6202 return nativeResponseValue;
6204 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6206 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
6207 if(!isWasmInitialized) {
6208 throw new Error("initializeWasm() must be awaited first!");
6210 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
6211 return nativeResponseValue;
6213 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6215 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
6216 if(!isWasmInitialized) {
6217 throw new Error("initializeWasm() must be awaited first!");
6219 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
6220 return nativeResponseValue;
6222 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6224 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
6229 return nativeResponseValue;
6231 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6233 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6234 if(!isWasmInitialized) {
6235 throw new Error("initializeWasm() must be awaited first!");
6237 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
6238 return nativeResponseValue;
6240 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6242 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
6247 return nativeResponseValue;
6249 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6251 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6252 if(!isWasmInitialized) {
6253 throw new Error("initializeWasm() must be awaited first!");
6255 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
6256 return nativeResponseValue;
6258 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6260 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
6265 return nativeResponseValue;
6267 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6269 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
6274 return nativeResponseValue;
6276 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6278 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
6283 return nativeResponseValue;
6285 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6287 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6288 if(!isWasmInitialized) {
6289 throw new Error("initializeWasm() must be awaited first!");
6291 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
6292 return nativeResponseValue;
6294 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6296 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6297 if(!isWasmInitialized) {
6298 throw new Error("initializeWasm() must be awaited first!");
6300 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
6301 return nativeResponseValue;
6303 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6305 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
6310 return nativeResponseValue;
6312 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6314 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
6319 return nativeResponseValue;
6321 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6323 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
6328 return nativeResponseValue;
6330 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6332 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
6337 return nativeResponseValue;
6339 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6341 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
6342 if(!isWasmInitialized) {
6343 throw new Error("initializeWasm() must be awaited first!");
6345 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
6346 return nativeResponseValue;
6348 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6350 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
6351 if(!isWasmInitialized) {
6352 throw new Error("initializeWasm() must be awaited first!");
6354 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
6355 return nativeResponseValue;
6357 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6359 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
6360 if(!isWasmInitialized) {
6361 throw new Error("initializeWasm() must be awaited first!");
6363 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
6364 return nativeResponseValue;
6366 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6368 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
6373 return nativeResponseValue;
6375 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6377 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6378 if(!isWasmInitialized) {
6379 throw new Error("initializeWasm() must be awaited first!");
6381 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
6382 return nativeResponseValue;
6384 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6386 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6387 if(!isWasmInitialized) {
6388 throw new Error("initializeWasm() must be awaited first!");
6390 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
6391 return nativeResponseValue;
6393 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6395 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6396 if(!isWasmInitialized) {
6397 throw new Error("initializeWasm() must be awaited first!");
6399 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
6400 return nativeResponseValue;
6402 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6404 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6405 if(!isWasmInitialized) {
6406 throw new Error("initializeWasm() must be awaited first!");
6408 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
6409 return nativeResponseValue;
6411 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6413 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
6418 return nativeResponseValue;
6420 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6422 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6423 if(!isWasmInitialized) {
6424 throw new Error("initializeWasm() must be awaited first!");
6426 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
6427 return nativeResponseValue;
6429 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6431 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6432 if(!isWasmInitialized) {
6433 throw new Error("initializeWasm() must be awaited first!");
6435 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
6436 return nativeResponseValue;
6438 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6440 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6441 if(!isWasmInitialized) {
6442 throw new Error("initializeWasm() must be awaited first!");
6444 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
6445 return nativeResponseValue;
6447 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6449 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6450 if(!isWasmInitialized) {
6451 throw new Error("initializeWasm() must be awaited first!");
6453 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
6454 return nativeResponseValue;
6456 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6458 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6459 if(!isWasmInitialized) {
6460 throw new Error("initializeWasm() must be awaited first!");
6462 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
6463 return nativeResponseValue;
6465 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6467 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6468 if(!isWasmInitialized) {
6469 throw new Error("initializeWasm() must be awaited first!");
6471 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
6472 return nativeResponseValue;
6474 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6476 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6477 if(!isWasmInitialized) {
6478 throw new Error("initializeWasm() must be awaited first!");
6480 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
6481 return nativeResponseValue;
6483 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6485 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6486 if(!isWasmInitialized) {
6487 throw new Error("initializeWasm() must be awaited first!");
6489 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
6490 return nativeResponseValue;
6492 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6494 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
6499 return nativeResponseValue;
6501 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6503 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6504 if(!isWasmInitialized) {
6505 throw new Error("initializeWasm() must be awaited first!");
6507 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
6508 return nativeResponseValue;
6510 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6512 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
6517 return nativeResponseValue;
6519 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6521 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
6526 return nativeResponseValue;
6528 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6530 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
6535 return nativeResponseValue;
6537 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6539 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
6544 return nativeResponseValue;
6546 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6548 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
6553 return nativeResponseValue;
6555 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6557 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
6562 return nativeResponseValue;
6564 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6566 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
6571 return nativeResponseValue;
6573 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6575 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
6580 return nativeResponseValue;
6582 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6584 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
6589 return nativeResponseValue;
6591 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6593 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
6598 return nativeResponseValue;
6601 export class LDKSignOrCreationError {
6602 protected constructor() {}
6605 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
6606 if(!isWasmInitialized) {
6607 throw new Error("initializeWasm() must be awaited first!");
6609 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
6610 return nativeResponseValue;
6613 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
6614 if(!isWasmInitialized) {
6615 throw new Error("initializeWasm() must be awaited first!");
6617 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
6618 return nativeResponseValue;
6620 // struct LDKBolt11Invoice CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6622 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
6623 if(!isWasmInitialized) {
6624 throw new Error("initializeWasm() must be awaited first!");
6626 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner);
6627 return nativeResponseValue;
6629 // struct LDKSignOrCreationError CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6631 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
6632 if(!isWasmInitialized) {
6633 throw new Error("initializeWasm() must be awaited first!");
6635 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner);
6636 return nativeResponseValue;
6638 // struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
6640 export function CResult_OffersMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6641 if(!isWasmInitialized) {
6642 throw new Error("initializeWasm() must be awaited first!");
6644 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_ok(owner);
6645 return nativeResponseValue;
6647 // struct LDKDecodeError CResult_OffersMessageDecodeErrorZ_get_err(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
6649 export function CResult_OffersMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6650 if(!isWasmInitialized) {
6651 throw new Error("initializeWasm() must be awaited first!");
6653 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_err(owner);
6654 return nativeResponseValue;
6657 export class LDKCOption_HTLCClaimZ {
6658 protected constructor() {}
6661 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
6662 if(!isWasmInitialized) {
6663 throw new Error("initializeWasm() must be awaited first!");
6665 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
6666 return nativeResponseValue;
6669 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
6670 if(!isWasmInitialized) {
6671 throw new Error("initializeWasm() must be awaited first!");
6673 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
6674 return nativeResponseValue;
6676 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
6678 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
6679 if(!isWasmInitialized) {
6680 throw new Error("initializeWasm() must be awaited first!");
6682 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
6683 return nativeResponseValue;
6685 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
6687 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
6688 if(!isWasmInitialized) {
6689 throw new Error("initializeWasm() must be awaited first!");
6691 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
6692 return nativeResponseValue;
6694 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
6696 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
6697 if(!isWasmInitialized) {
6698 throw new Error("initializeWasm() must be awaited first!");
6700 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
6701 return nativeResponseValue;
6703 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
6705 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
6706 if(!isWasmInitialized) {
6707 throw new Error("initializeWasm() must be awaited first!");
6709 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
6710 return nativeResponseValue;
6712 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
6714 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
6715 if(!isWasmInitialized) {
6716 throw new Error("initializeWasm() must be awaited first!");
6718 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
6719 return nativeResponseValue;
6721 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
6723 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
6724 if(!isWasmInitialized) {
6725 throw new Error("initializeWasm() must be awaited first!");
6727 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
6728 return nativeResponseValue;
6730 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
6732 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
6733 if(!isWasmInitialized) {
6734 throw new Error("initializeWasm() must be awaited first!");
6736 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
6737 return nativeResponseValue;
6739 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
6741 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
6742 if(!isWasmInitialized) {
6743 throw new Error("initializeWasm() must be awaited first!");
6745 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
6746 return nativeResponseValue;
6748 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6750 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
6751 if(!isWasmInitialized) {
6752 throw new Error("initializeWasm() must be awaited first!");
6754 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
6755 return nativeResponseValue;
6757 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6759 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
6760 if(!isWasmInitialized) {
6761 throw new Error("initializeWasm() must be awaited first!");
6763 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
6764 return nativeResponseValue;
6766 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6768 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
6769 if(!isWasmInitialized) {
6770 throw new Error("initializeWasm() must be awaited first!");
6772 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
6773 return nativeResponseValue;
6775 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6777 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
6778 if(!isWasmInitialized) {
6779 throw new Error("initializeWasm() must be awaited first!");
6781 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
6782 return nativeResponseValue;
6784 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6786 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
6787 if(!isWasmInitialized) {
6788 throw new Error("initializeWasm() must be awaited first!");
6790 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
6791 return nativeResponseValue;
6793 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6795 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
6796 if(!isWasmInitialized) {
6797 throw new Error("initializeWasm() must be awaited first!");
6799 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
6800 return nativeResponseValue;
6802 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6804 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
6805 if(!isWasmInitialized) {
6806 throw new Error("initializeWasm() must be awaited first!");
6808 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
6809 return nativeResponseValue;
6811 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6813 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
6814 if(!isWasmInitialized) {
6815 throw new Error("initializeWasm() must be awaited first!");
6817 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
6818 return nativeResponseValue;
6820 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
6822 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
6823 if(!isWasmInitialized) {
6824 throw new Error("initializeWasm() must be awaited first!");
6826 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
6827 return nativeResponseValue;
6829 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
6831 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
6832 if(!isWasmInitialized) {
6833 throw new Error("initializeWasm() must be awaited first!");
6835 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
6836 // debug statements here
6838 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6840 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
6841 if(!isWasmInitialized) {
6842 throw new Error("initializeWasm() must be awaited first!");
6844 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
6845 return nativeResponseValue;
6847 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6849 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
6850 if(!isWasmInitialized) {
6851 throw new Error("initializeWasm() must be awaited first!");
6853 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
6854 return nativeResponseValue;
6856 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
6858 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
6859 if(!isWasmInitialized) {
6860 throw new Error("initializeWasm() must be awaited first!");
6862 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
6863 return nativeResponseValue;
6865 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
6867 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
6868 if(!isWasmInitialized) {
6869 throw new Error("initializeWasm() must be awaited first!");
6871 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
6872 // debug statements here
6874 // struct LDKCVec_ECDSASignatureZ CResult_CVec_ECDSASignatureZNoneZ_get_ok(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
6876 export function CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner: bigint): number {
6877 if(!isWasmInitialized) {
6878 throw new Error("initializeWasm() must be awaited first!");
6880 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner);
6881 return nativeResponseValue;
6883 // void CResult_CVec_ECDSASignatureZNoneZ_get_err(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
6885 export function CResult_CVec_ECDSASignatureZNoneZ_get_err(owner: bigint): void {
6886 if(!isWasmInitialized) {
6887 throw new Error("initializeWasm() must be awaited first!");
6889 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_err(owner);
6890 // debug statements here
6893 export class LDKCOption_usizeZ {
6894 protected constructor() {}
6897 export function LDKCOption_usizeZ_ty_from_ptr(ptr: bigint): number {
6898 if(!isWasmInitialized) {
6899 throw new Error("initializeWasm() must be awaited first!");
6901 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_ty_from_ptr(ptr);
6902 return nativeResponseValue;
6905 export function LDKCOption_usizeZ_Some_get_some(ptr: bigint): number {
6906 if(!isWasmInitialized) {
6907 throw new Error("initializeWasm() must be awaited first!");
6909 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_Some_get_some(ptr);
6910 return nativeResponseValue;
6912 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
6914 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
6915 if(!isWasmInitialized) {
6916 throw new Error("initializeWasm() must be awaited first!");
6918 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
6919 return nativeResponseValue;
6921 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
6923 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
6924 if(!isWasmInitialized) {
6925 throw new Error("initializeWasm() must be awaited first!");
6927 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
6928 return nativeResponseValue;
6930 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
6932 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
6933 if(!isWasmInitialized) {
6934 throw new Error("initializeWasm() must be awaited first!");
6936 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
6937 return nativeResponseValue;
6939 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
6941 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
6942 if(!isWasmInitialized) {
6943 throw new Error("initializeWasm() must be awaited first!");
6945 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
6946 return nativeResponseValue;
6949 export class LDKPaymentPurpose {
6950 protected constructor() {}
6953 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
6954 if(!isWasmInitialized) {
6955 throw new Error("initializeWasm() must be awaited first!");
6957 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
6958 return nativeResponseValue;
6961 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): bigint {
6962 if(!isWasmInitialized) {
6963 throw new Error("initializeWasm() must be awaited first!");
6965 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
6966 return nativeResponseValue;
6969 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
6970 if(!isWasmInitialized) {
6971 throw new Error("initializeWasm() must be awaited first!");
6973 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
6974 return nativeResponseValue;
6977 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
6978 if(!isWasmInitialized) {
6979 throw new Error("initializeWasm() must be awaited first!");
6981 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
6982 return nativeResponseValue;
6984 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
6986 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
6987 if(!isWasmInitialized) {
6988 throw new Error("initializeWasm() must be awaited first!");
6990 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
6991 return nativeResponseValue;
6993 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
6995 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
6996 if(!isWasmInitialized) {
6997 throw new Error("initializeWasm() must be awaited first!");
6999 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
7000 return nativeResponseValue;
7002 // struct LDKClaimedHTLC CResult_ClaimedHTLCDecodeErrorZ_get_ok(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
7004 export function CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7005 if(!isWasmInitialized) {
7006 throw new Error("initializeWasm() must be awaited first!");
7008 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner);
7009 return nativeResponseValue;
7011 // struct LDKDecodeError CResult_ClaimedHTLCDecodeErrorZ_get_err(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
7013 export function CResult_ClaimedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7014 if(!isWasmInitialized) {
7015 throw new Error("initializeWasm() must be awaited first!");
7017 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_err(owner);
7018 return nativeResponseValue;
7021 export class LDKPathFailure {
7022 protected constructor() {}
7025 export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
7026 if(!isWasmInitialized) {
7027 throw new Error("initializeWasm() must be awaited first!");
7029 const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
7030 return nativeResponseValue;
7033 export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
7034 if(!isWasmInitialized) {
7035 throw new Error("initializeWasm() must be awaited first!");
7037 const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
7038 return nativeResponseValue;
7041 export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
7042 if(!isWasmInitialized) {
7043 throw new Error("initializeWasm() must be awaited first!");
7045 const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
7046 return nativeResponseValue;
7049 export class LDKCOption_PathFailureZ {
7050 protected constructor() {}
7053 export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
7054 if(!isWasmInitialized) {
7055 throw new Error("initializeWasm() must be awaited first!");
7057 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
7058 return nativeResponseValue;
7061 export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
7062 if(!isWasmInitialized) {
7063 throw new Error("initializeWasm() must be awaited first!");
7065 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
7066 return nativeResponseValue;
7068 // struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
7070 export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
7071 if(!isWasmInitialized) {
7072 throw new Error("initializeWasm() must be awaited first!");
7074 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
7075 return nativeResponseValue;
7077 // struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
7079 export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
7080 if(!isWasmInitialized) {
7081 throw new Error("initializeWasm() must be awaited first!");
7083 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
7084 return nativeResponseValue;
7087 export class LDKClosureReason {
7088 protected constructor() {}
7091 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
7092 if(!isWasmInitialized) {
7093 throw new Error("initializeWasm() must be awaited first!");
7095 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
7096 return nativeResponseValue;
7099 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): bigint {
7100 if(!isWasmInitialized) {
7101 throw new Error("initializeWasm() must be awaited first!");
7103 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
7104 return nativeResponseValue;
7107 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
7108 if(!isWasmInitialized) {
7109 throw new Error("initializeWasm() must be awaited first!");
7111 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
7112 return nativeResponseValue;
7115 export class LDKCOption_ClosureReasonZ {
7116 protected constructor() {}
7119 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
7120 if(!isWasmInitialized) {
7121 throw new Error("initializeWasm() must be awaited first!");
7123 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
7124 return nativeResponseValue;
7127 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
7128 if(!isWasmInitialized) {
7129 throw new Error("initializeWasm() must be awaited first!");
7131 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
7132 return nativeResponseValue;
7134 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
7136 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
7137 if(!isWasmInitialized) {
7138 throw new Error("initializeWasm() must be awaited first!");
7140 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
7141 return nativeResponseValue;
7143 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
7145 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
7146 if(!isWasmInitialized) {
7147 throw new Error("initializeWasm() must be awaited first!");
7149 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
7150 return nativeResponseValue;
7153 export class LDKHTLCDestination {
7154 protected constructor() {}
7157 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
7158 if(!isWasmInitialized) {
7159 throw new Error("initializeWasm() must be awaited first!");
7161 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
7162 return nativeResponseValue;
7165 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
7166 if(!isWasmInitialized) {
7167 throw new Error("initializeWasm() must be awaited first!");
7169 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
7170 return nativeResponseValue;
7173 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
7174 if(!isWasmInitialized) {
7175 throw new Error("initializeWasm() must be awaited first!");
7177 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
7178 return nativeResponseValue;
7181 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
7182 if(!isWasmInitialized) {
7183 throw new Error("initializeWasm() must be awaited first!");
7185 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
7186 return nativeResponseValue;
7189 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
7190 if(!isWasmInitialized) {
7191 throw new Error("initializeWasm() must be awaited first!");
7193 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
7194 return nativeResponseValue;
7197 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
7198 if(!isWasmInitialized) {
7199 throw new Error("initializeWasm() must be awaited first!");
7201 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
7202 return nativeResponseValue;
7205 export class LDKCOption_HTLCDestinationZ {
7206 protected constructor() {}
7209 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
7210 if(!isWasmInitialized) {
7211 throw new Error("initializeWasm() must be awaited first!");
7213 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
7214 return nativeResponseValue;
7217 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
7218 if(!isWasmInitialized) {
7219 throw new Error("initializeWasm() must be awaited first!");
7221 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
7222 return nativeResponseValue;
7224 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
7226 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
7227 if(!isWasmInitialized) {
7228 throw new Error("initializeWasm() must be awaited first!");
7230 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
7231 return nativeResponseValue;
7233 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
7235 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
7236 if(!isWasmInitialized) {
7237 throw new Error("initializeWasm() must be awaited first!");
7239 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
7240 return nativeResponseValue;
7242 // enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
7244 export function CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner: bigint): PaymentFailureReason {
7245 if(!isWasmInitialized) {
7246 throw new Error("initializeWasm() must be awaited first!");
7248 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner);
7249 return nativeResponseValue;
7251 // struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
7253 export function CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner: bigint): bigint {
7254 if(!isWasmInitialized) {
7255 throw new Error("initializeWasm() must be awaited first!");
7257 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner);
7258 return nativeResponseValue;
7261 export class LDKCOption_U128Z {
7262 protected constructor() {}
7265 export function LDKCOption_U128Z_ty_from_ptr(ptr: bigint): number {
7266 if(!isWasmInitialized) {
7267 throw new Error("initializeWasm() must be awaited first!");
7269 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_ty_from_ptr(ptr);
7270 return nativeResponseValue;
7273 export function LDKCOption_U128Z_Some_get_some(ptr: bigint): number {
7274 if(!isWasmInitialized) {
7275 throw new Error("initializeWasm() must be awaited first!");
7277 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_Some_get_some(ptr);
7278 return nativeResponseValue;
7281 export class LDKCOption_PaymentFailureReasonZ {
7282 protected constructor() {}
7285 export function LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr: bigint): number {
7286 if(!isWasmInitialized) {
7287 throw new Error("initializeWasm() must be awaited first!");
7289 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr);
7290 return nativeResponseValue;
7293 export function LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr: bigint): PaymentFailureReason {
7294 if(!isWasmInitialized) {
7295 throw new Error("initializeWasm() must be awaited first!");
7297 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr);
7298 return nativeResponseValue;
7301 export class LDKBumpTransactionEvent {
7302 protected constructor() {}
7305 export function LDKBumpTransactionEvent_ty_from_ptr(ptr: bigint): number {
7306 if(!isWasmInitialized) {
7307 throw new Error("initializeWasm() must be awaited first!");
7309 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ty_from_ptr(ptr);
7310 return nativeResponseValue;
7313 export function LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr: bigint): number {
7314 if(!isWasmInitialized) {
7315 throw new Error("initializeWasm() must be awaited first!");
7317 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr);
7318 return nativeResponseValue;
7321 export function LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr: bigint): number {
7322 if(!isWasmInitialized) {
7323 throw new Error("initializeWasm() must be awaited first!");
7325 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr);
7326 return nativeResponseValue;
7329 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr: bigint): number {
7330 if(!isWasmInitialized) {
7331 throw new Error("initializeWasm() must be awaited first!");
7333 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr);
7334 return nativeResponseValue;
7337 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr: bigint): bigint {
7338 if(!isWasmInitialized) {
7339 throw new Error("initializeWasm() must be awaited first!");
7341 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr);
7342 return nativeResponseValue;
7345 export function LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr: bigint): bigint {
7346 if(!isWasmInitialized) {
7347 throw new Error("initializeWasm() must be awaited first!");
7349 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr);
7350 return nativeResponseValue;
7353 export function LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr: bigint): number {
7354 if(!isWasmInitialized) {
7355 throw new Error("initializeWasm() must be awaited first!");
7357 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr);
7358 return nativeResponseValue;
7361 export function LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr: bigint): number {
7362 if(!isWasmInitialized) {
7363 throw new Error("initializeWasm() must be awaited first!");
7365 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr);
7366 return nativeResponseValue;
7369 export function LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr: bigint): number {
7370 if(!isWasmInitialized) {
7371 throw new Error("initializeWasm() must be awaited first!");
7373 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr);
7374 return nativeResponseValue;
7377 export function LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr: bigint): number {
7378 if(!isWasmInitialized) {
7379 throw new Error("initializeWasm() must be awaited first!");
7381 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr);
7382 return nativeResponseValue;
7385 export function LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr: bigint): number {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr);
7390 return nativeResponseValue;
7393 export class LDKEvent {
7394 protected constructor() {}
7397 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
7398 if(!isWasmInitialized) {
7399 throw new Error("initializeWasm() must be awaited first!");
7401 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
7402 return nativeResponseValue;
7405 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
7406 if(!isWasmInitialized) {
7407 throw new Error("initializeWasm() must be awaited first!");
7409 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
7410 return nativeResponseValue;
7413 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
7414 if(!isWasmInitialized) {
7415 throw new Error("initializeWasm() must be awaited first!");
7417 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
7418 return nativeResponseValue;
7421 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
7426 return nativeResponseValue;
7429 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
7430 if(!isWasmInitialized) {
7431 throw new Error("initializeWasm() must be awaited first!");
7433 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
7434 return nativeResponseValue;
7437 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
7438 if(!isWasmInitialized) {
7439 throw new Error("initializeWasm() must be awaited first!");
7441 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
7442 return nativeResponseValue;
7445 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
7446 if(!isWasmInitialized) {
7447 throw new Error("initializeWasm() must be awaited first!");
7449 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
7450 return nativeResponseValue;
7453 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
7454 if(!isWasmInitialized) {
7455 throw new Error("initializeWasm() must be awaited first!");
7457 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
7458 return nativeResponseValue;
7461 export function LDKEvent_PaymentClaimable_get_onion_fields(ptr: bigint): bigint {
7462 if(!isWasmInitialized) {
7463 throw new Error("initializeWasm() must be awaited first!");
7465 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_onion_fields(ptr);
7466 return nativeResponseValue;
7469 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
7470 if(!isWasmInitialized) {
7471 throw new Error("initializeWasm() must be awaited first!");
7473 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
7474 return nativeResponseValue;
7477 export function LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr: bigint): bigint {
7478 if(!isWasmInitialized) {
7479 throw new Error("initializeWasm() must be awaited first!");
7481 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr);
7482 return nativeResponseValue;
7485 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
7486 if(!isWasmInitialized) {
7487 throw new Error("initializeWasm() must be awaited first!");
7489 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
7490 return nativeResponseValue;
7493 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): bigint {
7494 if(!isWasmInitialized) {
7495 throw new Error("initializeWasm() must be awaited first!");
7497 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
7498 return nativeResponseValue;
7501 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
7502 if(!isWasmInitialized) {
7503 throw new Error("initializeWasm() must be awaited first!");
7505 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
7506 return nativeResponseValue;
7509 export function LDKEvent_PaymentClaimable_get_claim_deadline(ptr: bigint): bigint {
7510 if(!isWasmInitialized) {
7511 throw new Error("initializeWasm() must be awaited first!");
7513 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_claim_deadline(ptr);
7514 return nativeResponseValue;
7517 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
7518 if(!isWasmInitialized) {
7519 throw new Error("initializeWasm() must be awaited first!");
7521 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
7522 return nativeResponseValue;
7525 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
7526 if(!isWasmInitialized) {
7527 throw new Error("initializeWasm() must be awaited first!");
7529 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
7530 return nativeResponseValue;
7533 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
7534 if(!isWasmInitialized) {
7535 throw new Error("initializeWasm() must be awaited first!");
7537 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
7538 return nativeResponseValue;
7541 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
7542 if(!isWasmInitialized) {
7543 throw new Error("initializeWasm() must be awaited first!");
7545 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
7546 return nativeResponseValue;
7549 export function LDKEvent_PaymentClaimed_get_htlcs(ptr: bigint): number {
7550 if(!isWasmInitialized) {
7551 throw new Error("initializeWasm() must be awaited first!");
7553 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_htlcs(ptr);
7554 return nativeResponseValue;
7557 export function LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr: bigint): bigint {
7558 if(!isWasmInitialized) {
7559 throw new Error("initializeWasm() must be awaited first!");
7561 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr);
7562 return nativeResponseValue;
7565 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): bigint {
7566 if(!isWasmInitialized) {
7567 throw new Error("initializeWasm() must be awaited first!");
7569 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
7570 return nativeResponseValue;
7573 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
7574 if(!isWasmInitialized) {
7575 throw new Error("initializeWasm() must be awaited first!");
7577 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
7578 return nativeResponseValue;
7581 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
7582 if(!isWasmInitialized) {
7583 throw new Error("initializeWasm() must be awaited first!");
7585 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
7586 return nativeResponseValue;
7589 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
7590 if(!isWasmInitialized) {
7591 throw new Error("initializeWasm() must be awaited first!");
7593 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
7594 return nativeResponseValue;
7597 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
7598 if(!isWasmInitialized) {
7599 throw new Error("initializeWasm() must be awaited first!");
7601 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
7602 return nativeResponseValue;
7605 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
7606 if(!isWasmInitialized) {
7607 throw new Error("initializeWasm() must be awaited first!");
7609 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
7610 return nativeResponseValue;
7613 export function LDKEvent_PaymentFailed_get_reason(ptr: bigint): bigint {
7614 if(!isWasmInitialized) {
7615 throw new Error("initializeWasm() must be awaited first!");
7617 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_reason(ptr);
7618 return nativeResponseValue;
7621 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
7626 return nativeResponseValue;
7629 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): bigint {
7630 if(!isWasmInitialized) {
7631 throw new Error("initializeWasm() must be awaited first!");
7633 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
7634 return nativeResponseValue;
7637 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): bigint {
7638 if(!isWasmInitialized) {
7639 throw new Error("initializeWasm() must be awaited first!");
7641 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
7642 return nativeResponseValue;
7645 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): bigint {
7646 if(!isWasmInitialized) {
7647 throw new Error("initializeWasm() must be awaited first!");
7649 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
7650 return nativeResponseValue;
7653 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
7654 if(!isWasmInitialized) {
7655 throw new Error("initializeWasm() must be awaited first!");
7657 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
7658 return nativeResponseValue;
7661 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
7662 if(!isWasmInitialized) {
7663 throw new Error("initializeWasm() must be awaited first!");
7665 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
7666 return nativeResponseValue;
7669 export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
7670 if(!isWasmInitialized) {
7671 throw new Error("initializeWasm() must be awaited first!");
7673 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_failure(ptr);
7674 return nativeResponseValue;
7677 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): bigint {
7678 if(!isWasmInitialized) {
7679 throw new Error("initializeWasm() must be awaited first!");
7681 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
7682 return nativeResponseValue;
7685 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
7686 if(!isWasmInitialized) {
7687 throw new Error("initializeWasm() must be awaited first!");
7689 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
7690 return nativeResponseValue;
7693 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
7694 if(!isWasmInitialized) {
7695 throw new Error("initializeWasm() must be awaited first!");
7697 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
7698 return nativeResponseValue;
7701 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
7702 if(!isWasmInitialized) {
7703 throw new Error("initializeWasm() must be awaited first!");
7705 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
7706 return nativeResponseValue;
7709 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): bigint {
7710 if(!isWasmInitialized) {
7711 throw new Error("initializeWasm() must be awaited first!");
7713 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
7714 return nativeResponseValue;
7717 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
7718 if(!isWasmInitialized) {
7719 throw new Error("initializeWasm() must be awaited first!");
7721 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
7722 return nativeResponseValue;
7725 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
7726 if(!isWasmInitialized) {
7727 throw new Error("initializeWasm() must be awaited first!");
7729 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
7730 return nativeResponseValue;
7733 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): bigint {
7734 if(!isWasmInitialized) {
7735 throw new Error("initializeWasm() must be awaited first!");
7737 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
7738 return nativeResponseValue;
7741 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
7742 if(!isWasmInitialized) {
7743 throw new Error("initializeWasm() must be awaited first!");
7745 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
7746 return nativeResponseValue;
7749 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
7750 if(!isWasmInitialized) {
7751 throw new Error("initializeWasm() must be awaited first!");
7753 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
7754 return nativeResponseValue;
7757 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
7758 if(!isWasmInitialized) {
7759 throw new Error("initializeWasm() must be awaited first!");
7761 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
7762 return nativeResponseValue;
7765 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
7766 if(!isWasmInitialized) {
7767 throw new Error("initializeWasm() must be awaited first!");
7769 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
7770 return nativeResponseValue;
7773 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
7774 if(!isWasmInitialized) {
7775 throw new Error("initializeWasm() must be awaited first!");
7777 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
7778 return nativeResponseValue;
7781 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
7782 if(!isWasmInitialized) {
7783 throw new Error("initializeWasm() must be awaited first!");
7785 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
7786 return nativeResponseValue;
7789 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
7790 if(!isWasmInitialized) {
7791 throw new Error("initializeWasm() must be awaited first!");
7793 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
7794 return nativeResponseValue;
7797 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
7798 if(!isWasmInitialized) {
7799 throw new Error("initializeWasm() must be awaited first!");
7801 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
7802 return nativeResponseValue;
7805 export function LDKEvent_SpendableOutputs_get_channel_id(ptr: bigint): bigint {
7806 if(!isWasmInitialized) {
7807 throw new Error("initializeWasm() must be awaited first!");
7809 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_channel_id(ptr);
7810 return nativeResponseValue;
7813 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): bigint {
7814 if(!isWasmInitialized) {
7815 throw new Error("initializeWasm() must be awaited first!");
7817 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
7818 return nativeResponseValue;
7821 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): bigint {
7822 if(!isWasmInitialized) {
7823 throw new Error("initializeWasm() must be awaited first!");
7825 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
7826 return nativeResponseValue;
7829 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
7830 if(!isWasmInitialized) {
7831 throw new Error("initializeWasm() must be awaited first!");
7833 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
7834 return nativeResponseValue;
7837 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
7838 if(!isWasmInitialized) {
7839 throw new Error("initializeWasm() must be awaited first!");
7841 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
7842 return nativeResponseValue;
7845 export function LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr: bigint): bigint {
7846 if(!isWasmInitialized) {
7847 throw new Error("initializeWasm() must be awaited first!");
7849 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr);
7850 return nativeResponseValue;
7853 export function LDKEvent_ChannelPending_get_channel_id(ptr: bigint): number {
7854 if(!isWasmInitialized) {
7855 throw new Error("initializeWasm() must be awaited first!");
7857 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_id(ptr);
7858 return nativeResponseValue;
7861 export function LDKEvent_ChannelPending_get_user_channel_id(ptr: bigint): number {
7862 if(!isWasmInitialized) {
7863 throw new Error("initializeWasm() must be awaited first!");
7865 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_user_channel_id(ptr);
7866 return nativeResponseValue;
7869 export function LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr: bigint): bigint {
7870 if(!isWasmInitialized) {
7871 throw new Error("initializeWasm() must be awaited first!");
7873 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr);
7874 return nativeResponseValue;
7877 export function LDKEvent_ChannelPending_get_counterparty_node_id(ptr: bigint): number {
7878 if(!isWasmInitialized) {
7879 throw new Error("initializeWasm() must be awaited first!");
7881 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_counterparty_node_id(ptr);
7882 return nativeResponseValue;
7885 export function LDKEvent_ChannelPending_get_funding_txo(ptr: bigint): bigint {
7886 if(!isWasmInitialized) {
7887 throw new Error("initializeWasm() must be awaited first!");
7889 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_funding_txo(ptr);
7890 return nativeResponseValue;
7893 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
7894 if(!isWasmInitialized) {
7895 throw new Error("initializeWasm() must be awaited first!");
7897 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
7898 return nativeResponseValue;
7901 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
7902 if(!isWasmInitialized) {
7903 throw new Error("initializeWasm() must be awaited first!");
7905 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
7906 return nativeResponseValue;
7909 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
7914 return nativeResponseValue;
7917 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
7918 if(!isWasmInitialized) {
7919 throw new Error("initializeWasm() must be awaited first!");
7921 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
7922 return nativeResponseValue;
7925 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
7926 if(!isWasmInitialized) {
7927 throw new Error("initializeWasm() must be awaited first!");
7929 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
7930 return nativeResponseValue;
7933 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
7934 if(!isWasmInitialized) {
7935 throw new Error("initializeWasm() must be awaited first!");
7937 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
7938 return nativeResponseValue;
7941 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
7942 if(!isWasmInitialized) {
7943 throw new Error("initializeWasm() must be awaited first!");
7945 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
7946 return nativeResponseValue;
7949 export function LDKEvent_ChannelClosed_get_counterparty_node_id(ptr: bigint): number {
7950 if(!isWasmInitialized) {
7951 throw new Error("initializeWasm() must be awaited first!");
7953 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_counterparty_node_id(ptr);
7954 return nativeResponseValue;
7957 export function LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr: bigint): bigint {
7958 if(!isWasmInitialized) {
7959 throw new Error("initializeWasm() must be awaited first!");
7961 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr);
7962 return nativeResponseValue;
7965 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
7966 if(!isWasmInitialized) {
7967 throw new Error("initializeWasm() must be awaited first!");
7969 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
7970 return nativeResponseValue;
7973 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
7974 if(!isWasmInitialized) {
7975 throw new Error("initializeWasm() must be awaited first!");
7977 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
7978 return nativeResponseValue;
7981 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
7982 if(!isWasmInitialized) {
7983 throw new Error("initializeWasm() must be awaited first!");
7985 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
7986 return nativeResponseValue;
7989 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
7990 if(!isWasmInitialized) {
7991 throw new Error("initializeWasm() must be awaited first!");
7993 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
7994 return nativeResponseValue;
7997 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
7998 if(!isWasmInitialized) {
7999 throw new Error("initializeWasm() must be awaited first!");
8001 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
8002 return nativeResponseValue;
8005 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
8006 if(!isWasmInitialized) {
8007 throw new Error("initializeWasm() must be awaited first!");
8009 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
8010 return nativeResponseValue;
8013 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
8014 if(!isWasmInitialized) {
8015 throw new Error("initializeWasm() must be awaited first!");
8017 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
8018 return nativeResponseValue;
8021 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
8022 if(!isWasmInitialized) {
8023 throw new Error("initializeWasm() must be awaited first!");
8025 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
8026 return nativeResponseValue;
8029 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
8030 if(!isWasmInitialized) {
8031 throw new Error("initializeWasm() must be awaited first!");
8033 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
8034 return nativeResponseValue;
8037 export function LDKEvent_BumpTransaction_get_bump_transaction(ptr: bigint): bigint {
8038 if(!isWasmInitialized) {
8039 throw new Error("initializeWasm() must be awaited first!");
8041 const nativeResponseValue = wasm.TS_LDKEvent_BumpTransaction_get_bump_transaction(ptr);
8042 return nativeResponseValue;
8045 export class LDKCOption_EventZ {
8046 protected constructor() {}
8049 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
8050 if(!isWasmInitialized) {
8051 throw new Error("initializeWasm() must be awaited first!");
8053 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
8054 return nativeResponseValue;
8057 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
8058 if(!isWasmInitialized) {
8059 throw new Error("initializeWasm() must be awaited first!");
8061 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
8062 return nativeResponseValue;
8064 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
8066 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
8067 if(!isWasmInitialized) {
8068 throw new Error("initializeWasm() must be awaited first!");
8070 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
8071 return nativeResponseValue;
8073 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
8075 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
8076 if(!isWasmInitialized) {
8077 throw new Error("initializeWasm() must be awaited first!");
8079 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
8080 return nativeResponseValue;
8083 export class LDKBolt11ParseError {
8084 protected constructor() {}
8087 export function LDKBolt11ParseError_ty_from_ptr(ptr: bigint): number {
8088 if(!isWasmInitialized) {
8089 throw new Error("initializeWasm() must be awaited first!");
8091 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ty_from_ptr(ptr);
8092 return nativeResponseValue;
8095 export function LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
8096 if(!isWasmInitialized) {
8097 throw new Error("initializeWasm() must be awaited first!");
8099 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr);
8100 return nativeResponseValue;
8103 export function LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
8104 if(!isWasmInitialized) {
8105 throw new Error("initializeWasm() must be awaited first!");
8107 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr);
8108 return nativeResponseValue;
8111 export function LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
8112 if(!isWasmInitialized) {
8113 throw new Error("initializeWasm() must be awaited first!");
8115 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr);
8116 return nativeResponseValue;
8119 export function LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
8120 if(!isWasmInitialized) {
8121 throw new Error("initializeWasm() must be awaited first!");
8123 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr);
8124 return nativeResponseValue;
8127 export function LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
8128 if(!isWasmInitialized) {
8129 throw new Error("initializeWasm() must be awaited first!");
8131 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
8132 return nativeResponseValue;
8134 // enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8136 export function CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner: bigint): SiPrefix {
8137 if(!isWasmInitialized) {
8138 throw new Error("initializeWasm() must be awaited first!");
8140 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner);
8141 return nativeResponseValue;
8143 // struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8145 export function CResult_SiPrefixBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8146 if(!isWasmInitialized) {
8147 throw new Error("initializeWasm() must be awaited first!");
8149 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_err(owner);
8150 return nativeResponseValue;
8153 export class LDKParseOrSemanticError {
8154 protected constructor() {}
8157 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
8158 if(!isWasmInitialized) {
8159 throw new Error("initializeWasm() must be awaited first!");
8161 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
8162 return nativeResponseValue;
8165 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
8166 if(!isWasmInitialized) {
8167 throw new Error("initializeWasm() must be awaited first!");
8169 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
8170 return nativeResponseValue;
8173 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): Bolt11SemanticError {
8174 if(!isWasmInitialized) {
8175 throw new Error("initializeWasm() must be awaited first!");
8177 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
8178 return nativeResponseValue;
8180 // struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8182 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
8183 if(!isWasmInitialized) {
8184 throw new Error("initializeWasm() must be awaited first!");
8186 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner);
8187 return nativeResponseValue;
8189 // struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8191 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
8192 if(!isWasmInitialized) {
8193 throw new Error("initializeWasm() must be awaited first!");
8195 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner);
8196 return nativeResponseValue;
8198 // struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8200 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner: bigint): bigint {
8201 if(!isWasmInitialized) {
8202 throw new Error("initializeWasm() must be awaited first!");
8204 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner);
8205 return nativeResponseValue;
8207 // struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8209 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8210 if(!isWasmInitialized) {
8211 throw new Error("initializeWasm() must be awaited first!");
8213 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner);
8214 return nativeResponseValue;
8216 // struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8218 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner: bigint): bigint {
8219 if(!isWasmInitialized) {
8220 throw new Error("initializeWasm() must be awaited first!");
8222 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner);
8223 return nativeResponseValue;
8225 // struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8227 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner: bigint): number {
8228 if(!isWasmInitialized) {
8229 throw new Error("initializeWasm() must be awaited first!");
8231 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner);
8232 return nativeResponseValue;
8234 // struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8236 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner: bigint): bigint {
8237 if(!isWasmInitialized) {
8238 throw new Error("initializeWasm() must be awaited first!");
8240 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner);
8241 return nativeResponseValue;
8243 // struct LDKPayeePubKey CResult_PayeePubKeySecp256k1ErrorZ_get_ok(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
8245 export function CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner: bigint): bigint {
8246 if(!isWasmInitialized) {
8247 throw new Error("initializeWasm() must be awaited first!");
8249 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner);
8250 return nativeResponseValue;
8252 // enum LDKSecp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
8254 export function CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
8255 if(!isWasmInitialized) {
8256 throw new Error("initializeWasm() must be awaited first!");
8258 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner);
8259 return nativeResponseValue;
8261 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8263 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
8264 if(!isWasmInitialized) {
8265 throw new Error("initializeWasm() must be awaited first!");
8267 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
8268 return nativeResponseValue;
8270 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8272 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
8273 if(!isWasmInitialized) {
8274 throw new Error("initializeWasm() must be awaited first!");
8276 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
8277 return nativeResponseValue;
8279 // void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8281 export function CResult_NoneBolt11SemanticErrorZ_get_ok(owner: bigint): void {
8282 if(!isWasmInitialized) {
8283 throw new Error("initializeWasm() must be awaited first!");
8285 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_ok(owner);
8286 // debug statements here
8288 // enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8290 export function CResult_NoneBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8291 if(!isWasmInitialized) {
8292 throw new Error("initializeWasm() must be awaited first!");
8294 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_err(owner);
8295 return nativeResponseValue;
8297 // struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
8299 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner: bigint): bigint {
8300 if(!isWasmInitialized) {
8301 throw new Error("initializeWasm() must be awaited first!");
8303 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner);
8304 return nativeResponseValue;
8306 // enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
8308 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8309 if(!isWasmInitialized) {
8310 throw new Error("initializeWasm() must be awaited first!");
8312 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner);
8313 return nativeResponseValue;
8315 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
8317 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
8318 if(!isWasmInitialized) {
8319 throw new Error("initializeWasm() must be awaited first!");
8321 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
8322 return nativeResponseValue;
8324 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
8326 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
8327 if(!isWasmInitialized) {
8328 throw new Error("initializeWasm() must be awaited first!");
8330 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
8331 return nativeResponseValue;
8333 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
8335 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
8336 if(!isWasmInitialized) {
8337 throw new Error("initializeWasm() must be awaited first!");
8339 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
8340 return nativeResponseValue;
8342 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
8344 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
8345 if(!isWasmInitialized) {
8346 throw new Error("initializeWasm() must be awaited first!");
8348 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
8349 return nativeResponseValue;
8351 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
8353 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
8354 if(!isWasmInitialized) {
8355 throw new Error("initializeWasm() must be awaited first!");
8357 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
8358 return nativeResponseValue;
8360 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
8362 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
8363 if(!isWasmInitialized) {
8364 throw new Error("initializeWasm() must be awaited first!");
8366 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
8367 return nativeResponseValue;
8369 // struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
8371 export function CResult_BigSizeDecodeErrorZ_get_ok(owner: bigint): bigint {
8372 if(!isWasmInitialized) {
8373 throw new Error("initializeWasm() must be awaited first!");
8375 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_ok(owner);
8376 return nativeResponseValue;
8378 // struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
8380 export function CResult_BigSizeDecodeErrorZ_get_err(owner: bigint): bigint {
8381 if(!isWasmInitialized) {
8382 throw new Error("initializeWasm() must be awaited first!");
8384 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_err(owner);
8385 return nativeResponseValue;
8387 // struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
8389 export function CResult_HostnameDecodeErrorZ_get_ok(owner: bigint): bigint {
8390 if(!isWasmInitialized) {
8391 throw new Error("initializeWasm() must be awaited first!");
8393 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_ok(owner);
8394 return nativeResponseValue;
8396 // struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
8398 export function CResult_HostnameDecodeErrorZ_get_err(owner: bigint): bigint {
8399 if(!isWasmInitialized) {
8400 throw new Error("initializeWasm() must be awaited first!");
8402 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_err(owner);
8403 return nativeResponseValue;
8405 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
8407 export function CResult_TransactionU16LenLimitedNoneZ_get_ok(owner: bigint): bigint {
8408 if(!isWasmInitialized) {
8409 throw new Error("initializeWasm() must be awaited first!");
8411 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_ok(owner);
8412 return nativeResponseValue;
8414 // void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
8416 export function CResult_TransactionU16LenLimitedNoneZ_get_err(owner: bigint): void {
8417 if(!isWasmInitialized) {
8418 throw new Error("initializeWasm() must be awaited first!");
8420 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_err(owner);
8421 // debug statements here
8423 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
8425 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner: bigint): bigint {
8426 if(!isWasmInitialized) {
8427 throw new Error("initializeWasm() must be awaited first!");
8429 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner);
8430 return nativeResponseValue;
8432 // struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
8434 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner: bigint): bigint {
8435 if(!isWasmInitialized) {
8436 throw new Error("initializeWasm() must be awaited first!");
8438 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner);
8439 return nativeResponseValue;
8441 // struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
8443 export function CResult_UntrustedStringDecodeErrorZ_get_ok(owner: bigint): bigint {
8444 if(!isWasmInitialized) {
8445 throw new Error("initializeWasm() must be awaited first!");
8447 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_ok(owner);
8448 return nativeResponseValue;
8450 // struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
8452 export function CResult_UntrustedStringDecodeErrorZ_get_err(owner: bigint): bigint {
8453 if(!isWasmInitialized) {
8454 throw new Error("initializeWasm() must be awaited first!");
8456 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_err(owner);
8457 return nativeResponseValue;
8459 // struct LDKReceiveTlvs CResult_ReceiveTlvsDecodeErrorZ_get_ok(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR owner);
8461 export function CResult_ReceiveTlvsDecodeErrorZ_get_ok(owner: bigint): bigint {
8462 if(!isWasmInitialized) {
8463 throw new Error("initializeWasm() must be awaited first!");
8465 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_get_ok(owner);
8466 return nativeResponseValue;
8468 // struct LDKDecodeError CResult_ReceiveTlvsDecodeErrorZ_get_err(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR owner);
8470 export function CResult_ReceiveTlvsDecodeErrorZ_get_err(owner: bigint): bigint {
8471 if(!isWasmInitialized) {
8472 throw new Error("initializeWasm() must be awaited first!");
8474 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_get_err(owner);
8475 return nativeResponseValue;
8477 // struct LDKPaymentRelay CResult_PaymentRelayDecodeErrorZ_get_ok(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
8479 export function CResult_PaymentRelayDecodeErrorZ_get_ok(owner: bigint): bigint {
8480 if(!isWasmInitialized) {
8481 throw new Error("initializeWasm() must be awaited first!");
8483 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_ok(owner);
8484 return nativeResponseValue;
8486 // struct LDKDecodeError CResult_PaymentRelayDecodeErrorZ_get_err(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
8488 export function CResult_PaymentRelayDecodeErrorZ_get_err(owner: bigint): bigint {
8489 if(!isWasmInitialized) {
8490 throw new Error("initializeWasm() must be awaited first!");
8492 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_err(owner);
8493 return nativeResponseValue;
8495 // struct LDKPaymentConstraints CResult_PaymentConstraintsDecodeErrorZ_get_ok(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
8497 export function CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner: bigint): bigint {
8498 if(!isWasmInitialized) {
8499 throw new Error("initializeWasm() must be awaited first!");
8501 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner);
8502 return nativeResponseValue;
8504 // struct LDKDecodeError CResult_PaymentConstraintsDecodeErrorZ_get_err(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
8506 export function CResult_PaymentConstraintsDecodeErrorZ_get_err(owner: bigint): bigint {
8507 if(!isWasmInitialized) {
8508 throw new Error("initializeWasm() must be awaited first!");
8510 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_err(owner);
8511 return nativeResponseValue;
8514 export class LDKPaymentError {
8515 protected constructor() {}
8518 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
8519 if(!isWasmInitialized) {
8520 throw new Error("initializeWasm() must be awaited first!");
8522 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
8523 return nativeResponseValue;
8526 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
8527 if(!isWasmInitialized) {
8528 throw new Error("initializeWasm() must be awaited first!");
8530 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
8531 return nativeResponseValue;
8534 export function LDKPaymentError_Sending_get_sending(ptr: bigint): RetryableSendFailure {
8535 if(!isWasmInitialized) {
8536 throw new Error("initializeWasm() must be awaited first!");
8538 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
8539 return nativeResponseValue;
8541 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR owner);
8543 export function CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(owner: bigint): number {
8544 if(!isWasmInitialized) {
8545 throw new Error("initializeWasm() must be awaited first!");
8547 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(owner);
8548 return nativeResponseValue;
8550 // struct LDKPaymentError CResult_ThirtyTwoBytesPaymentErrorZ_get_err(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR owner);
8552 export function CResult_ThirtyTwoBytesPaymentErrorZ_get_err(owner: bigint): bigint {
8553 if(!isWasmInitialized) {
8554 throw new Error("initializeWasm() must be awaited first!");
8556 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_err(owner);
8557 return nativeResponseValue;
8559 // void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
8561 export function CResult_NonePaymentErrorZ_get_ok(owner: bigint): void {
8562 if(!isWasmInitialized) {
8563 throw new Error("initializeWasm() must be awaited first!");
8565 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_ok(owner);
8566 // debug statements here
8568 // struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
8570 export function CResult_NonePaymentErrorZ_get_err(owner: bigint): bigint {
8571 if(!isWasmInitialized) {
8572 throw new Error("initializeWasm() must be awaited first!");
8574 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_err(owner);
8575 return nativeResponseValue;
8578 export class LDKProbingError {
8579 protected constructor() {}
8582 export function LDKProbingError_ty_from_ptr(ptr: bigint): number {
8583 if(!isWasmInitialized) {
8584 throw new Error("initializeWasm() must be awaited first!");
8586 const nativeResponseValue = wasm.TS_LDKProbingError_ty_from_ptr(ptr);
8587 return nativeResponseValue;
8590 export function LDKProbingError_Invoice_get_invoice(ptr: bigint): number {
8591 if(!isWasmInitialized) {
8592 throw new Error("initializeWasm() must be awaited first!");
8594 const nativeResponseValue = wasm.TS_LDKProbingError_Invoice_get_invoice(ptr);
8595 return nativeResponseValue;
8598 export function LDKProbingError_Sending_get_sending(ptr: bigint): bigint {
8599 if(!isWasmInitialized) {
8600 throw new Error("initializeWasm() must be awaited first!");
8602 const nativeResponseValue = wasm.TS_LDKProbingError_Sending_get_sending(ptr);
8603 return nativeResponseValue;
8605 // struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR owner);
8607 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(owner: bigint): number {
8608 if(!isWasmInitialized) {
8609 throw new Error("initializeWasm() must be awaited first!");
8611 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(owner);
8612 return nativeResponseValue;
8614 // struct LDKProbingError CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR owner);
8616 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(owner: bigint): bigint {
8617 if(!isWasmInitialized) {
8618 throw new Error("initializeWasm() must be awaited first!");
8620 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(owner);
8621 return nativeResponseValue;
8623 // struct LDKStr CResult_StrSecp256k1ErrorZ_get_ok(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
8625 export function CResult_StrSecp256k1ErrorZ_get_ok(owner: bigint): number {
8626 if(!isWasmInitialized) {
8627 throw new Error("initializeWasm() must be awaited first!");
8629 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_ok(owner);
8630 return nativeResponseValue;
8632 // enum LDKSecp256k1Error CResult_StrSecp256k1ErrorZ_get_err(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
8634 export function CResult_StrSecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
8635 if(!isWasmInitialized) {
8636 throw new Error("initializeWasm() must be awaited first!");
8638 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_err(owner);
8639 return nativeResponseValue;
8641 // struct LDKOnionMessagePath CResult_OnionMessagePathNoneZ_get_ok(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
8643 export function CResult_OnionMessagePathNoneZ_get_ok(owner: bigint): bigint {
8644 if(!isWasmInitialized) {
8645 throw new Error("initializeWasm() must be awaited first!");
8647 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_ok(owner);
8648 return nativeResponseValue;
8650 // void CResult_OnionMessagePathNoneZ_get_err(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
8652 export function CResult_OnionMessagePathNoneZ_get_err(owner: bigint): void {
8653 if(!isWasmInitialized) {
8654 throw new Error("initializeWasm() must be awaited first!");
8656 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_err(owner);
8657 // debug statements here
8659 // struct LDKPublicKey C2Tuple_PublicKeyOnionMessageZ_get_a(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR owner);
8661 export function C2Tuple_PublicKeyOnionMessageZ_get_a(owner: bigint): number {
8662 if(!isWasmInitialized) {
8663 throw new Error("initializeWasm() must be awaited first!");
8665 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_get_a(owner);
8666 return nativeResponseValue;
8668 // struct LDKOnionMessage C2Tuple_PublicKeyOnionMessageZ_get_b(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR owner);
8670 export function C2Tuple_PublicKeyOnionMessageZ_get_b(owner: bigint): bigint {
8671 if(!isWasmInitialized) {
8672 throw new Error("initializeWasm() must be awaited first!");
8674 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_get_b(owner);
8675 return nativeResponseValue;
8678 export class LDKSendError {
8679 protected constructor() {}
8682 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
8683 if(!isWasmInitialized) {
8684 throw new Error("initializeWasm() must be awaited first!");
8686 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
8687 return nativeResponseValue;
8690 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
8691 if(!isWasmInitialized) {
8692 throw new Error("initializeWasm() must be awaited first!");
8694 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
8695 return nativeResponseValue;
8697 // struct LDKC2Tuple_PublicKeyOnionMessageZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR owner);
8699 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(owner: bigint): bigint {
8700 if(!isWasmInitialized) {
8701 throw new Error("initializeWasm() must be awaited first!");
8703 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(owner);
8704 return nativeResponseValue;
8706 // struct LDKSendError CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR owner);
8708 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(owner: bigint): bigint {
8709 if(!isWasmInitialized) {
8710 throw new Error("initializeWasm() must be awaited first!");
8712 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(owner);
8713 return nativeResponseValue;
8715 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
8717 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
8718 if(!isWasmInitialized) {
8719 throw new Error("initializeWasm() must be awaited first!");
8721 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
8722 // debug statements here
8724 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
8726 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
8727 if(!isWasmInitialized) {
8728 throw new Error("initializeWasm() must be awaited first!");
8730 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
8731 return nativeResponseValue;
8733 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
8735 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
8736 if(!isWasmInitialized) {
8737 throw new Error("initializeWasm() must be awaited first!");
8739 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
8740 return nativeResponseValue;
8742 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
8744 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
8745 if(!isWasmInitialized) {
8746 throw new Error("initializeWasm() must be awaited first!");
8748 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
8749 // debug statements here
8751 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
8753 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner: bigint): bigint {
8754 if(!isWasmInitialized) {
8755 throw new Error("initializeWasm() must be awaited first!");
8757 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner);
8758 return nativeResponseValue;
8760 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
8762 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner: bigint): void {
8763 if(!isWasmInitialized) {
8764 throw new Error("initializeWasm() must be awaited first!");
8766 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner);
8767 // debug statements here
8769 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
8771 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
8772 if(!isWasmInitialized) {
8773 throw new Error("initializeWasm() must be awaited first!");
8775 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
8776 return nativeResponseValue;
8778 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
8780 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
8781 if(!isWasmInitialized) {
8782 throw new Error("initializeWasm() must be awaited first!");
8784 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
8785 return nativeResponseValue;
8787 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
8789 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
8790 if(!isWasmInitialized) {
8791 throw new Error("initializeWasm() must be awaited first!");
8793 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
8794 return nativeResponseValue;
8796 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
8798 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
8799 if(!isWasmInitialized) {
8800 throw new Error("initializeWasm() must be awaited first!");
8802 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
8803 return nativeResponseValue;
8805 // struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
8807 export function CResult_InvoiceErrorDecodeErrorZ_get_ok(owner: bigint): bigint {
8808 if(!isWasmInitialized) {
8809 throw new Error("initializeWasm() must be awaited first!");
8811 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_ok(owner);
8812 return nativeResponseValue;
8814 // struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
8816 export function CResult_InvoiceErrorDecodeErrorZ_get_err(owner: bigint): bigint {
8817 if(!isWasmInitialized) {
8818 throw new Error("initializeWasm() must be awaited first!");
8820 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_err(owner);
8821 return nativeResponseValue;
8824 export interface LDKFilter {
8825 register_tx (txid: number, script_pubkey: number): void;
8826 register_output (output: bigint): void;
8830 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
8831 if(!isWasmInitialized) {
8832 throw new Error("initializeWasm() must be awaited first!");
8834 var new_obj_idx = js_objs.length;
8835 for (var i = 0; i < js_objs.length; i++) {
8836 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8838 js_objs[i] = new WeakRef(impl);
8839 return [wasm.TS_LDKFilter_new(i), i];
8841 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
8843 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
8844 if(!isWasmInitialized) {
8845 throw new Error("initializeWasm() must be awaited first!");
8847 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
8848 // debug statements here
8850 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
8852 export function Filter_register_output(this_arg: bigint, output: bigint): void {
8853 if(!isWasmInitialized) {
8854 throw new Error("initializeWasm() must be awaited first!");
8856 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
8857 // debug statements here
8860 export class LDKCOption_FilterZ {
8861 protected constructor() {}
8864 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
8865 if(!isWasmInitialized) {
8866 throw new Error("initializeWasm() must be awaited first!");
8868 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
8869 return nativeResponseValue;
8872 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
8873 if(!isWasmInitialized) {
8874 throw new Error("initializeWasm() must be awaited first!");
8876 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
8877 return nativeResponseValue;
8879 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
8881 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
8882 if(!isWasmInitialized) {
8883 throw new Error("initializeWasm() must be awaited first!");
8885 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
8886 return nativeResponseValue;
8888 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
8890 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
8891 if(!isWasmInitialized) {
8892 throw new Error("initializeWasm() must be awaited first!");
8894 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
8895 // debug statements here
8897 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
8899 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
8900 if(!isWasmInitialized) {
8901 throw new Error("initializeWasm() must be awaited first!");
8903 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
8904 return nativeResponseValue;
8906 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
8908 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
8909 if(!isWasmInitialized) {
8910 throw new Error("initializeWasm() must be awaited first!");
8912 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
8913 return nativeResponseValue;
8916 export interface LDKKVStore {
8917 read (primary_namespace: number, secondary_namespace: number, key: number): bigint;
8918 write (primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint;
8919 remove (primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint;
8920 list (primary_namespace: number, secondary_namespace: number): bigint;
8924 export function LDKKVStore_new(impl: LDKKVStore): [bigint, number] {
8925 if(!isWasmInitialized) {
8926 throw new Error("initializeWasm() must be awaited first!");
8928 var new_obj_idx = js_objs.length;
8929 for (var i = 0; i < js_objs.length; i++) {
8930 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8932 js_objs[i] = new WeakRef(impl);
8933 return [wasm.TS_LDKKVStore_new(i), i];
8935 // LDKCResult_CVec_u8ZIOErrorZ KVStore_read LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key
8937 export function KVStore_read(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number): bigint {
8938 if(!isWasmInitialized) {
8939 throw new Error("initializeWasm() must be awaited first!");
8941 const nativeResponseValue = wasm.TS_KVStore_read(this_arg, primary_namespace, secondary_namespace, key);
8942 return nativeResponseValue;
8944 // LDKCResult_NoneIOErrorZ KVStore_write LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf
8946 export function KVStore_write(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint {
8947 if(!isWasmInitialized) {
8948 throw new Error("initializeWasm() must be awaited first!");
8950 const nativeResponseValue = wasm.TS_KVStore_write(this_arg, primary_namespace, secondary_namespace, key, buf);
8951 return nativeResponseValue;
8953 // LDKCResult_NoneIOErrorZ KVStore_remove LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy
8955 export function KVStore_remove(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint {
8956 if(!isWasmInitialized) {
8957 throw new Error("initializeWasm() must be awaited first!");
8959 const nativeResponseValue = wasm.TS_KVStore_remove(this_arg, primary_namespace, secondary_namespace, key, lazy);
8960 return nativeResponseValue;
8962 // LDKCResult_CVec_StrZIOErrorZ KVStore_list LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace
8964 export function KVStore_list(this_arg: bigint, primary_namespace: number, secondary_namespace: number): bigint {
8965 if(!isWasmInitialized) {
8966 throw new Error("initializeWasm() must be awaited first!");
8968 const nativeResponseValue = wasm.TS_KVStore_list(this_arg, primary_namespace, secondary_namespace);
8969 return nativeResponseValue;
8972 export interface LDKScoreLookUp {
8973 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint, score_params: bigint): bigint;
8977 export function LDKScoreLookUp_new(impl: LDKScoreLookUp): [bigint, number] {
8978 if(!isWasmInitialized) {
8979 throw new Error("initializeWasm() must be awaited first!");
8981 var new_obj_idx = js_objs.length;
8982 for (var i = 0; i < js_objs.length; i++) {
8983 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
8985 js_objs[i] = new WeakRef(impl);
8986 return [wasm.TS_LDKScoreLookUp_new(i), i];
8988 // uint64_t ScoreLookUp_channel_penalty_msat LDKScoreLookUp *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
8990 export function ScoreLookUp_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint, score_params: bigint): bigint {
8991 if(!isWasmInitialized) {
8992 throw new Error("initializeWasm() must be awaited first!");
8994 const nativeResponseValue = wasm.TS_ScoreLookUp_channel_penalty_msat(this_arg, short_channel_id, source, target, usage, score_params);
8995 return nativeResponseValue;
8998 export interface LDKScoreUpdate {
8999 payment_path_failed (path: bigint, short_channel_id: bigint): void;
9000 payment_path_successful (path: bigint): void;
9001 probe_failed (path: bigint, short_channel_id: bigint): void;
9002 probe_successful (path: bigint): void;
9006 export function LDKScoreUpdate_new(impl: LDKScoreUpdate): [bigint, number] {
9007 if(!isWasmInitialized) {
9008 throw new Error("initializeWasm() must be awaited first!");
9010 var new_obj_idx = js_objs.length;
9011 for (var i = 0; i < js_objs.length; i++) {
9012 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9014 js_objs[i] = new WeakRef(impl);
9015 return [wasm.TS_LDKScoreUpdate_new(i), i];
9017 // void ScoreUpdate_payment_path_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
9019 export function ScoreUpdate_payment_path_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
9020 if(!isWasmInitialized) {
9021 throw new Error("initializeWasm() must be awaited first!");
9023 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_failed(this_arg, path, short_channel_id);
9024 // debug statements here
9026 // void ScoreUpdate_payment_path_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
9028 export function ScoreUpdate_payment_path_successful(this_arg: bigint, path: bigint): void {
9029 if(!isWasmInitialized) {
9030 throw new Error("initializeWasm() must be awaited first!");
9032 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_successful(this_arg, path);
9033 // debug statements here
9035 // void ScoreUpdate_probe_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
9037 export function ScoreUpdate_probe_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
9038 if(!isWasmInitialized) {
9039 throw new Error("initializeWasm() must be awaited first!");
9041 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_failed(this_arg, path, short_channel_id);
9042 // debug statements here
9044 // void ScoreUpdate_probe_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
9046 export function ScoreUpdate_probe_successful(this_arg: bigint, path: bigint): void {
9047 if(!isWasmInitialized) {
9048 throw new Error("initializeWasm() must be awaited first!");
9050 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_successful(this_arg, path);
9051 // debug statements here
9054 export interface LDKLockableScore {
9055 read_lock (): bigint;
9056 write_lock (): bigint;
9060 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
9061 if(!isWasmInitialized) {
9062 throw new Error("initializeWasm() must be awaited first!");
9064 var new_obj_idx = js_objs.length;
9065 for (var i = 0; i < js_objs.length; i++) {
9066 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9068 js_objs[i] = new WeakRef(impl);
9069 return [wasm.TS_LDKLockableScore_new(i), i];
9071 // LDKScoreLookUp LockableScore_read_lock LDKLockableScore *NONNULL_PTR this_arg
9073 export function LockableScore_read_lock(this_arg: bigint): bigint {
9074 if(!isWasmInitialized) {
9075 throw new Error("initializeWasm() must be awaited first!");
9077 const nativeResponseValue = wasm.TS_LockableScore_read_lock(this_arg);
9078 return nativeResponseValue;
9080 // LDKScoreUpdate LockableScore_write_lock LDKLockableScore *NONNULL_PTR this_arg
9082 export function LockableScore_write_lock(this_arg: bigint): bigint {
9083 if(!isWasmInitialized) {
9084 throw new Error("initializeWasm() must be awaited first!");
9086 const nativeResponseValue = wasm.TS_LockableScore_write_lock(this_arg);
9087 return nativeResponseValue;
9090 export interface LDKWriteableScore {
9095 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
9096 if(!isWasmInitialized) {
9097 throw new Error("initializeWasm() must be awaited first!");
9099 var new_obj_idx = js_objs.length;
9100 for (var i = 0; i < js_objs.length; i++) {
9101 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9103 js_objs[i] = new WeakRef(impl);
9104 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
9106 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
9108 export function WriteableScore_write(this_arg: bigint): number {
9109 if(!isWasmInitialized) {
9110 throw new Error("initializeWasm() must be awaited first!");
9112 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
9113 return nativeResponseValue;
9116 export interface LDKPersister {
9117 persist_manager (channel_manager: bigint): bigint;
9118 persist_graph (network_graph: bigint): bigint;
9119 persist_scorer (scorer: bigint): bigint;
9123 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
9124 if(!isWasmInitialized) {
9125 throw new Error("initializeWasm() must be awaited first!");
9127 var new_obj_idx = js_objs.length;
9128 for (var i = 0; i < js_objs.length; i++) {
9129 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9131 js_objs[i] = new WeakRef(impl);
9132 return [wasm.TS_LDKPersister_new(i), i];
9134 // LDKCResult_NoneIOErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
9136 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
9137 if(!isWasmInitialized) {
9138 throw new Error("initializeWasm() must be awaited first!");
9140 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
9141 return nativeResponseValue;
9143 // LDKCResult_NoneIOErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
9145 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
9146 if(!isWasmInitialized) {
9147 throw new Error("initializeWasm() must be awaited first!");
9149 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
9150 return nativeResponseValue;
9152 // LDKCResult_NoneIOErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
9154 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
9155 if(!isWasmInitialized) {
9156 throw new Error("initializeWasm() must be awaited first!");
9158 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
9159 return nativeResponseValue;
9162 export interface LDKPersist {
9163 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
9164 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
9168 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
9169 if(!isWasmInitialized) {
9170 throw new Error("initializeWasm() must be awaited first!");
9172 var new_obj_idx = js_objs.length;
9173 for (var i = 0; i < js_objs.length; i++) {
9174 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9176 js_objs[i] = new WeakRef(impl);
9177 return [wasm.TS_LDKPersist_new(i), i];
9179 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
9181 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
9182 if(!isWasmInitialized) {
9183 throw new Error("initializeWasm() must be awaited first!");
9185 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
9186 return nativeResponseValue;
9188 // 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
9190 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
9191 if(!isWasmInitialized) {
9192 throw new Error("initializeWasm() must be awaited first!");
9194 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
9195 return nativeResponseValue;
9198 export interface LDKFutureCallback {
9203 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
9204 if(!isWasmInitialized) {
9205 throw new Error("initializeWasm() must be awaited first!");
9207 var new_obj_idx = js_objs.length;
9208 for (var i = 0; i < js_objs.length; i++) {
9209 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9211 js_objs[i] = new WeakRef(impl);
9212 return [wasm.TS_LDKFutureCallback_new(i), i];
9214 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
9216 export function FutureCallback_call(this_arg: bigint): void {
9217 if(!isWasmInitialized) {
9218 throw new Error("initializeWasm() must be awaited first!");
9220 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
9221 // debug statements here
9224 export interface LDKListen {
9225 filtered_block_connected (header: number, txdata: number, height: number): void;
9226 block_connected (block: number, height: number): void;
9227 block_disconnected (header: number, height: number): void;
9231 export function LDKListen_new(impl: LDKListen): [bigint, number] {
9232 if(!isWasmInitialized) {
9233 throw new Error("initializeWasm() must be awaited first!");
9235 var new_obj_idx = js_objs.length;
9236 for (var i = 0; i < js_objs.length; i++) {
9237 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9239 js_objs[i] = new WeakRef(impl);
9240 return [wasm.TS_LDKListen_new(i), i];
9242 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
9244 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
9245 if(!isWasmInitialized) {
9246 throw new Error("initializeWasm() must be awaited first!");
9248 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
9249 // debug statements here
9251 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
9253 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
9254 if(!isWasmInitialized) {
9255 throw new Error("initializeWasm() must be awaited first!");
9257 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
9258 // debug statements here
9260 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
9262 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
9263 if(!isWasmInitialized) {
9264 throw new Error("initializeWasm() must be awaited first!");
9266 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
9267 // debug statements here
9270 export interface LDKConfirm {
9271 transactions_confirmed (header: number, txdata: number, height: number): void;
9272 transaction_unconfirmed (txid: number): void;
9273 best_block_updated (header: number, height: number): void;
9274 get_relevant_txids (): number;
9278 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
9279 if(!isWasmInitialized) {
9280 throw new Error("initializeWasm() must be awaited first!");
9282 var new_obj_idx = js_objs.length;
9283 for (var i = 0; i < js_objs.length; i++) {
9284 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9286 js_objs[i] = new WeakRef(impl);
9287 return [wasm.TS_LDKConfirm_new(i), i];
9289 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
9291 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
9292 if(!isWasmInitialized) {
9293 throw new Error("initializeWasm() must be awaited first!");
9295 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
9296 // debug statements here
9298 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
9300 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
9301 if(!isWasmInitialized) {
9302 throw new Error("initializeWasm() must be awaited first!");
9304 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
9305 // debug statements here
9307 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
9309 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
9310 if(!isWasmInitialized) {
9311 throw new Error("initializeWasm() must be awaited first!");
9313 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
9314 // debug statements here
9316 // LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
9318 export function Confirm_get_relevant_txids(this_arg: bigint): number {
9319 if(!isWasmInitialized) {
9320 throw new Error("initializeWasm() must be awaited first!");
9322 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
9323 return nativeResponseValue;
9326 export interface LDKEventHandler {
9327 handle_event (event: bigint): void;
9331 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
9332 if(!isWasmInitialized) {
9333 throw new Error("initializeWasm() must be awaited first!");
9335 var new_obj_idx = js_objs.length;
9336 for (var i = 0; i < js_objs.length; i++) {
9337 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9339 js_objs[i] = new WeakRef(impl);
9340 return [wasm.TS_LDKEventHandler_new(i), i];
9342 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
9344 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
9345 if(!isWasmInitialized) {
9346 throw new Error("initializeWasm() must be awaited first!");
9348 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
9349 // debug statements here
9352 export interface LDKEventsProvider {
9353 process_pending_events (handler: bigint): void;
9357 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
9358 if(!isWasmInitialized) {
9359 throw new Error("initializeWasm() must be awaited first!");
9361 var new_obj_idx = js_objs.length;
9362 for (var i = 0; i < js_objs.length; i++) {
9363 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9365 js_objs[i] = new WeakRef(impl);
9366 return [wasm.TS_LDKEventsProvider_new(i), i];
9368 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
9370 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
9371 if(!isWasmInitialized) {
9372 throw new Error("initializeWasm() must be awaited first!");
9374 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
9375 // debug statements here
9378 export class LDKFailureCode {
9379 protected constructor() {}
9382 export function LDKFailureCode_ty_from_ptr(ptr: bigint): number {
9383 if(!isWasmInitialized) {
9384 throw new Error("initializeWasm() must be awaited first!");
9386 const nativeResponseValue = wasm.TS_LDKFailureCode_ty_from_ptr(ptr);
9387 return nativeResponseValue;
9390 export function LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr: bigint): bigint {
9391 if(!isWasmInitialized) {
9392 throw new Error("initializeWasm() must be awaited first!");
9394 const nativeResponseValue = wasm.TS_LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr);
9395 return nativeResponseValue;
9398 export interface LDKMessageSendEventsProvider {
9399 get_and_clear_pending_msg_events (): number;
9403 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
9404 if(!isWasmInitialized) {
9405 throw new Error("initializeWasm() must be awaited first!");
9407 var new_obj_idx = js_objs.length;
9408 for (var i = 0; i < js_objs.length; i++) {
9409 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9411 js_objs[i] = new WeakRef(impl);
9412 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
9414 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
9416 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
9417 if(!isWasmInitialized) {
9418 throw new Error("initializeWasm() must be awaited first!");
9420 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
9421 return nativeResponseValue;
9424 export interface LDKChannelMessageHandler {
9425 handle_open_channel (their_node_id: number, msg: bigint): void;
9426 handle_open_channel_v2 (their_node_id: number, msg: bigint): void;
9427 handle_accept_channel (their_node_id: number, msg: bigint): void;
9428 handle_accept_channel_v2 (their_node_id: number, msg: bigint): void;
9429 handle_funding_created (their_node_id: number, msg: bigint): void;
9430 handle_funding_signed (their_node_id: number, msg: bigint): void;
9431 handle_channel_ready (their_node_id: number, msg: bigint): void;
9432 handle_shutdown (their_node_id: number, msg: bigint): void;
9433 handle_closing_signed (their_node_id: number, msg: bigint): void;
9434 handle_tx_add_input (their_node_id: number, msg: bigint): void;
9435 handle_tx_add_output (their_node_id: number, msg: bigint): void;
9436 handle_tx_remove_input (their_node_id: number, msg: bigint): void;
9437 handle_tx_remove_output (their_node_id: number, msg: bigint): void;
9438 handle_tx_complete (their_node_id: number, msg: bigint): void;
9439 handle_tx_signatures (their_node_id: number, msg: bigint): void;
9440 handle_tx_init_rbf (their_node_id: number, msg: bigint): void;
9441 handle_tx_ack_rbf (their_node_id: number, msg: bigint): void;
9442 handle_tx_abort (their_node_id: number, msg: bigint): void;
9443 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
9444 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
9445 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
9446 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
9447 handle_commitment_signed (their_node_id: number, msg: bigint): void;
9448 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
9449 handle_update_fee (their_node_id: number, msg: bigint): void;
9450 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
9451 peer_disconnected (their_node_id: number): void;
9452 peer_connected (their_node_id: number, msg: bigint, inbound: boolean): bigint;
9453 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
9454 handle_channel_update (their_node_id: number, msg: bigint): void;
9455 handle_error (their_node_id: number, msg: bigint): void;
9456 provided_node_features (): bigint;
9457 provided_init_features (their_node_id: number): bigint;
9458 get_genesis_hashes (): bigint;
9462 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
9463 if(!isWasmInitialized) {
9464 throw new Error("initializeWasm() must be awaited first!");
9466 var new_obj_idx = js_objs.length;
9467 for (var i = 0; i < js_objs.length; i++) {
9468 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9470 js_objs[i] = new WeakRef(impl);
9471 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
9473 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
9475 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
9476 if(!isWasmInitialized) {
9477 throw new Error("initializeWasm() must be awaited first!");
9479 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, msg);
9480 // debug statements here
9482 // void ChannelMessageHandler_handle_open_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg
9484 export function ChannelMessageHandler_handle_open_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
9485 if(!isWasmInitialized) {
9486 throw new Error("initializeWasm() must be awaited first!");
9488 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel_v2(this_arg, their_node_id, msg);
9489 // debug statements here
9491 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
9493 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
9494 if(!isWasmInitialized) {
9495 throw new Error("initializeWasm() must be awaited first!");
9497 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, msg);
9498 // debug statements here
9500 // void ChannelMessageHandler_handle_accept_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg
9502 export function ChannelMessageHandler_handle_accept_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
9503 if(!isWasmInitialized) {
9504 throw new Error("initializeWasm() must be awaited first!");
9506 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel_v2(this_arg, their_node_id, msg);
9507 // debug statements here
9509 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
9511 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
9512 if(!isWasmInitialized) {
9513 throw new Error("initializeWasm() must be awaited first!");
9515 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
9516 // debug statements here
9518 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
9520 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9521 if(!isWasmInitialized) {
9522 throw new Error("initializeWasm() must be awaited first!");
9524 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
9525 // debug statements here
9527 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
9529 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
9534 // debug statements here
9536 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
9538 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, msg: bigint): void {
9539 if(!isWasmInitialized) {
9540 throw new Error("initializeWasm() must be awaited first!");
9542 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, msg);
9543 // debug statements here
9545 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
9547 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9548 if(!isWasmInitialized) {
9549 throw new Error("initializeWasm() must be awaited first!");
9551 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
9552 // debug statements here
9554 // void ChannelMessageHandler_handle_tx_add_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg
9556 export function ChannelMessageHandler_handle_tx_add_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
9557 if(!isWasmInitialized) {
9558 throw new Error("initializeWasm() must be awaited first!");
9560 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_input(this_arg, their_node_id, msg);
9561 // debug statements here
9563 // void ChannelMessageHandler_handle_tx_add_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg
9565 export function ChannelMessageHandler_handle_tx_add_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
9566 if(!isWasmInitialized) {
9567 throw new Error("initializeWasm() must be awaited first!");
9569 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_output(this_arg, their_node_id, msg);
9570 // debug statements here
9572 // void ChannelMessageHandler_handle_tx_remove_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg
9574 export function ChannelMessageHandler_handle_tx_remove_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
9575 if(!isWasmInitialized) {
9576 throw new Error("initializeWasm() must be awaited first!");
9578 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_input(this_arg, their_node_id, msg);
9579 // debug statements here
9581 // void ChannelMessageHandler_handle_tx_remove_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg
9583 export function ChannelMessageHandler_handle_tx_remove_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
9584 if(!isWasmInitialized) {
9585 throw new Error("initializeWasm() must be awaited first!");
9587 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_output(this_arg, their_node_id, msg);
9588 // debug statements here
9590 // void ChannelMessageHandler_handle_tx_complete LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg
9592 export function ChannelMessageHandler_handle_tx_complete(this_arg: bigint, their_node_id: number, msg: bigint): void {
9593 if(!isWasmInitialized) {
9594 throw new Error("initializeWasm() must be awaited first!");
9596 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_complete(this_arg, their_node_id, msg);
9597 // debug statements here
9599 // void ChannelMessageHandler_handle_tx_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg
9601 export function ChannelMessageHandler_handle_tx_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
9602 if(!isWasmInitialized) {
9603 throw new Error("initializeWasm() must be awaited first!");
9605 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_signatures(this_arg, their_node_id, msg);
9606 // debug statements here
9608 // void ChannelMessageHandler_handle_tx_init_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg
9610 export function ChannelMessageHandler_handle_tx_init_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
9611 if(!isWasmInitialized) {
9612 throw new Error("initializeWasm() must be awaited first!");
9614 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_init_rbf(this_arg, their_node_id, msg);
9615 // debug statements here
9617 // void ChannelMessageHandler_handle_tx_ack_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg
9619 export function ChannelMessageHandler_handle_tx_ack_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
9620 if(!isWasmInitialized) {
9621 throw new Error("initializeWasm() must be awaited first!");
9623 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_ack_rbf(this_arg, their_node_id, msg);
9624 // debug statements here
9626 // void ChannelMessageHandler_handle_tx_abort LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg
9628 export function ChannelMessageHandler_handle_tx_abort(this_arg: bigint, their_node_id: number, msg: bigint): void {
9629 if(!isWasmInitialized) {
9630 throw new Error("initializeWasm() must be awaited first!");
9632 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_abort(this_arg, their_node_id, msg);
9633 // debug statements here
9635 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
9637 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9638 if(!isWasmInitialized) {
9639 throw new Error("initializeWasm() must be awaited first!");
9641 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
9642 // debug statements here
9644 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
9646 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9647 if(!isWasmInitialized) {
9648 throw new Error("initializeWasm() must be awaited first!");
9650 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
9651 // debug statements here
9653 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
9655 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9656 if(!isWasmInitialized) {
9657 throw new Error("initializeWasm() must be awaited first!");
9659 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
9660 // debug statements here
9662 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
9664 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9665 if(!isWasmInitialized) {
9666 throw new Error("initializeWasm() must be awaited first!");
9668 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
9669 // debug statements here
9671 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
9673 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9674 if(!isWasmInitialized) {
9675 throw new Error("initializeWasm() must be awaited first!");
9677 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
9678 // debug statements here
9680 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
9682 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
9683 if(!isWasmInitialized) {
9684 throw new Error("initializeWasm() must be awaited first!");
9686 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
9687 // debug statements here
9689 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
9691 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
9692 if(!isWasmInitialized) {
9693 throw new Error("initializeWasm() must be awaited first!");
9695 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
9696 // debug statements here
9698 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
9700 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
9701 if(!isWasmInitialized) {
9702 throw new Error("initializeWasm() must be awaited first!");
9704 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
9705 // debug statements here
9707 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9709 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
9710 if(!isWasmInitialized) {
9711 throw new Error("initializeWasm() must be awaited first!");
9713 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id);
9714 // debug statements here
9716 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
9718 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint, inbound: boolean): bigint {
9719 if(!isWasmInitialized) {
9720 throw new Error("initializeWasm() must be awaited first!");
9722 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg, inbound);
9723 return nativeResponseValue;
9725 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
9727 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
9728 if(!isWasmInitialized) {
9729 throw new Error("initializeWasm() must be awaited first!");
9731 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
9732 // debug statements here
9734 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
9736 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
9737 if(!isWasmInitialized) {
9738 throw new Error("initializeWasm() must be awaited first!");
9740 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
9741 // debug statements here
9743 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
9745 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
9746 if(!isWasmInitialized) {
9747 throw new Error("initializeWasm() must be awaited first!");
9749 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
9750 // debug statements here
9752 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
9754 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
9755 if(!isWasmInitialized) {
9756 throw new Error("initializeWasm() must be awaited first!");
9758 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
9759 return nativeResponseValue;
9761 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9763 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
9764 if(!isWasmInitialized) {
9765 throw new Error("initializeWasm() must be awaited first!");
9767 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
9768 return nativeResponseValue;
9770 // LDKCOption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler_get_genesis_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
9772 export function ChannelMessageHandler_get_genesis_hashes(this_arg: bigint): bigint {
9773 if(!isWasmInitialized) {
9774 throw new Error("initializeWasm() must be awaited first!");
9776 const nativeResponseValue = wasm.TS_ChannelMessageHandler_get_genesis_hashes(this_arg);
9777 return nativeResponseValue;
9780 export interface LDKRoutingMessageHandler {
9781 handle_node_announcement (msg: bigint): bigint;
9782 handle_channel_announcement (msg: bigint): bigint;
9783 handle_channel_update (msg: bigint): bigint;
9784 get_next_channel_announcement (starting_point: bigint): bigint;
9785 get_next_node_announcement (starting_point: bigint): bigint;
9786 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
9787 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
9788 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
9789 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
9790 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
9791 processing_queue_high (): boolean;
9792 provided_node_features (): bigint;
9793 provided_init_features (their_node_id: number): bigint;
9797 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
9798 if(!isWasmInitialized) {
9799 throw new Error("initializeWasm() must be awaited first!");
9801 var new_obj_idx = js_objs.length;
9802 for (var i = 0; i < js_objs.length; i++) {
9803 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9805 js_objs[i] = new WeakRef(impl);
9806 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
9808 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
9810 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
9811 if(!isWasmInitialized) {
9812 throw new Error("initializeWasm() must be awaited first!");
9814 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
9815 return nativeResponseValue;
9817 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
9819 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
9820 if(!isWasmInitialized) {
9821 throw new Error("initializeWasm() must be awaited first!");
9823 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
9824 return nativeResponseValue;
9826 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
9828 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
9829 if(!isWasmInitialized) {
9830 throw new Error("initializeWasm() must be awaited first!");
9832 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
9833 return nativeResponseValue;
9835 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
9837 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
9838 if(!isWasmInitialized) {
9839 throw new Error("initializeWasm() must be awaited first!");
9841 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
9842 return nativeResponseValue;
9844 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
9846 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
9847 if(!isWasmInitialized) {
9848 throw new Error("initializeWasm() must be awaited first!");
9850 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
9851 return nativeResponseValue;
9853 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
9855 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
9856 if(!isWasmInitialized) {
9857 throw new Error("initializeWasm() must be awaited first!");
9859 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
9860 return nativeResponseValue;
9862 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
9864 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9865 if(!isWasmInitialized) {
9866 throw new Error("initializeWasm() must be awaited first!");
9868 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
9869 return nativeResponseValue;
9871 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
9873 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9874 if(!isWasmInitialized) {
9875 throw new Error("initializeWasm() must be awaited first!");
9877 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
9878 return nativeResponseValue;
9880 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
9882 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9883 if(!isWasmInitialized) {
9884 throw new Error("initializeWasm() must be awaited first!");
9886 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
9887 return nativeResponseValue;
9889 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
9891 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
9892 if(!isWasmInitialized) {
9893 throw new Error("initializeWasm() must be awaited first!");
9895 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
9896 return nativeResponseValue;
9898 // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
9900 export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
9901 if(!isWasmInitialized) {
9902 throw new Error("initializeWasm() must be awaited first!");
9904 const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
9905 return nativeResponseValue;
9907 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
9909 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
9910 if(!isWasmInitialized) {
9911 throw new Error("initializeWasm() must be awaited first!");
9913 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
9914 return nativeResponseValue;
9916 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9918 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
9919 if(!isWasmInitialized) {
9920 throw new Error("initializeWasm() must be awaited first!");
9922 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
9923 return nativeResponseValue;
9926 export interface LDKOnionMessageProvider {
9927 next_onion_message_for_peer (peer_node_id: number): bigint;
9931 export function LDKOnionMessageProvider_new(impl: LDKOnionMessageProvider): [bigint, number] {
9932 if(!isWasmInitialized) {
9933 throw new Error("initializeWasm() must be awaited first!");
9935 var new_obj_idx = js_objs.length;
9936 for (var i = 0; i < js_objs.length; i++) {
9937 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9939 js_objs[i] = new WeakRef(impl);
9940 return [wasm.TS_LDKOnionMessageProvider_new(i), i];
9942 // LDKOnionMessage OnionMessageProvider_next_onion_message_for_peer LDKOnionMessageProvider *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
9944 export function OnionMessageProvider_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
9945 if(!isWasmInitialized) {
9946 throw new Error("initializeWasm() must be awaited first!");
9948 const nativeResponseValue = wasm.TS_OnionMessageProvider_next_onion_message_for_peer(this_arg, peer_node_id);
9949 return nativeResponseValue;
9952 export interface LDKOnionMessageHandler {
9953 handle_onion_message (peer_node_id: number, msg: bigint): void;
9954 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
9955 peer_disconnected (their_node_id: number): void;
9956 provided_node_features (): bigint;
9957 provided_init_features (their_node_id: number): bigint;
9961 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler, OnionMessageProvider: number): [bigint, number] {
9962 if(!isWasmInitialized) {
9963 throw new Error("initializeWasm() must be awaited first!");
9965 var new_obj_idx = js_objs.length;
9966 for (var i = 0; i < js_objs.length; i++) {
9967 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9969 js_objs[i] = new WeakRef(impl);
9970 return [wasm.TS_LDKOnionMessageHandler_new(i, OnionMessageProvider), i];
9972 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
9974 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
9975 if(!isWasmInitialized) {
9976 throw new Error("initializeWasm() must be awaited first!");
9978 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
9979 // debug statements here
9981 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
9983 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
9984 if(!isWasmInitialized) {
9985 throw new Error("initializeWasm() must be awaited first!");
9987 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
9988 return nativeResponseValue;
9990 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
9992 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
9993 if(!isWasmInitialized) {
9994 throw new Error("initializeWasm() must be awaited first!");
9996 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
9997 // debug statements here
9999 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
10001 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
10002 if(!isWasmInitialized) {
10003 throw new Error("initializeWasm() must be awaited first!");
10005 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
10006 return nativeResponseValue;
10008 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10010 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10011 if(!isWasmInitialized) {
10012 throw new Error("initializeWasm() must be awaited first!");
10014 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
10015 return nativeResponseValue;
10018 export interface LDKCustomMessageReader {
10019 read (message_type: number, buffer: number): bigint;
10023 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
10024 if(!isWasmInitialized) {
10025 throw new Error("initializeWasm() must be awaited first!");
10027 var new_obj_idx = js_objs.length;
10028 for (var i = 0; i < js_objs.length; i++) {
10029 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10031 js_objs[i] = new WeakRef(impl);
10032 return [wasm.TS_LDKCustomMessageReader_new(i), i];
10034 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
10036 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
10037 if(!isWasmInitialized) {
10038 throw new Error("initializeWasm() must be awaited first!");
10040 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
10041 return nativeResponseValue;
10044 export interface LDKCustomMessageHandler {
10045 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
10046 get_and_clear_pending_msg (): number;
10047 provided_node_features (): bigint;
10048 provided_init_features (their_node_id: number): bigint;
10052 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
10053 if(!isWasmInitialized) {
10054 throw new Error("initializeWasm() must be awaited first!");
10056 var new_obj_idx = js_objs.length;
10057 for (var i = 0; i < js_objs.length; i++) {
10058 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10060 js_objs[i] = new WeakRef(impl);
10061 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
10063 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
10065 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
10066 if(!isWasmInitialized) {
10067 throw new Error("initializeWasm() must be awaited first!");
10069 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
10070 return nativeResponseValue;
10072 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
10074 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
10075 if(!isWasmInitialized) {
10076 throw new Error("initializeWasm() must be awaited first!");
10078 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
10079 return nativeResponseValue;
10081 // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
10083 export function CustomMessageHandler_provided_node_features(this_arg: bigint): bigint {
10084 if(!isWasmInitialized) {
10085 throw new Error("initializeWasm() must be awaited first!");
10087 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_node_features(this_arg);
10088 return nativeResponseValue;
10090 // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10092 export function CustomMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10093 if(!isWasmInitialized) {
10094 throw new Error("initializeWasm() must be awaited first!");
10096 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_init_features(this_arg, their_node_id);
10097 return nativeResponseValue;
10100 export interface LDKOffersMessageHandler {
10101 handle_message (message: bigint): bigint;
10105 export function LDKOffersMessageHandler_new(impl: LDKOffersMessageHandler): [bigint, number] {
10106 if(!isWasmInitialized) {
10107 throw new Error("initializeWasm() must be awaited first!");
10109 var new_obj_idx = js_objs.length;
10110 for (var i = 0; i < js_objs.length; i++) {
10111 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10113 js_objs[i] = new WeakRef(impl);
10114 return [wasm.TS_LDKOffersMessageHandler_new(i), i];
10116 // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
10118 export function OffersMessageHandler_handle_message(this_arg: bigint, message: bigint): bigint {
10119 if(!isWasmInitialized) {
10120 throw new Error("initializeWasm() must be awaited first!");
10122 const nativeResponseValue = wasm.TS_OffersMessageHandler_handle_message(this_arg, message);
10123 return nativeResponseValue;
10126 export interface LDKCustomOnionMessageHandler {
10127 handle_custom_message (msg: bigint): bigint;
10128 read_custom_message (message_type: bigint, buffer: number): bigint;
10132 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
10133 if(!isWasmInitialized) {
10134 throw new Error("initializeWasm() must be awaited first!");
10136 var new_obj_idx = js_objs.length;
10137 for (var i = 0; i < js_objs.length; i++) {
10138 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10140 js_objs[i] = new WeakRef(impl);
10141 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
10143 // LDKCOption_CustomOnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKCustomOnionMessageContents msg
10145 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): bigint {
10146 if(!isWasmInitialized) {
10147 throw new Error("initializeWasm() must be awaited first!");
10149 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
10150 return nativeResponseValue;
10152 // LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
10154 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
10155 if(!isWasmInitialized) {
10156 throw new Error("initializeWasm() must be awaited first!");
10158 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
10159 return nativeResponseValue;
10162 export interface LDKSocketDescriptor {
10163 send_data (data: number, resume_read: boolean): number;
10164 disconnect_socket (): void;
10165 eq (other_arg: bigint): boolean;
10170 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
10171 if(!isWasmInitialized) {
10172 throw new Error("initializeWasm() must be awaited first!");
10174 var new_obj_idx = js_objs.length;
10175 for (var i = 0; i < js_objs.length; i++) {
10176 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10178 js_objs[i] = new WeakRef(impl);
10179 return [wasm.TS_LDKSocketDescriptor_new(i), i];
10181 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
10183 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
10184 if(!isWasmInitialized) {
10185 throw new Error("initializeWasm() must be awaited first!");
10187 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
10188 return nativeResponseValue;
10190 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
10192 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
10193 if(!isWasmInitialized) {
10194 throw new Error("initializeWasm() must be awaited first!");
10196 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
10197 // debug statements here
10199 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
10201 export function SocketDescriptor_hash(this_arg: bigint): bigint {
10202 if(!isWasmInitialized) {
10203 throw new Error("initializeWasm() must be awaited first!");
10205 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
10206 return nativeResponseValue;
10209 export class LDKEffectiveCapacity {
10210 protected constructor() {}
10213 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
10214 if(!isWasmInitialized) {
10215 throw new Error("initializeWasm() must be awaited first!");
10217 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
10218 return nativeResponseValue;
10221 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
10222 if(!isWasmInitialized) {
10223 throw new Error("initializeWasm() must be awaited first!");
10225 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
10226 return nativeResponseValue;
10229 export function LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr: bigint): bigint {
10230 if(!isWasmInitialized) {
10231 throw new Error("initializeWasm() must be awaited first!");
10233 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr);
10234 return nativeResponseValue;
10237 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
10238 if(!isWasmInitialized) {
10239 throw new Error("initializeWasm() must be awaited first!");
10241 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
10242 return nativeResponseValue;
10245 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
10246 if(!isWasmInitialized) {
10247 throw new Error("initializeWasm() must be awaited first!");
10249 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
10250 return nativeResponseValue;
10253 export function LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr: bigint): bigint {
10254 if(!isWasmInitialized) {
10255 throw new Error("initializeWasm() must be awaited first!");
10257 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr);
10258 return nativeResponseValue;
10261 export class LDKPayee {
10262 protected constructor() {}
10265 export function LDKPayee_ty_from_ptr(ptr: bigint): number {
10266 if(!isWasmInitialized) {
10267 throw new Error("initializeWasm() must be awaited first!");
10269 const nativeResponseValue = wasm.TS_LDKPayee_ty_from_ptr(ptr);
10270 return nativeResponseValue;
10273 export function LDKPayee_Blinded_get_route_hints(ptr: bigint): number {
10274 if(!isWasmInitialized) {
10275 throw new Error("initializeWasm() must be awaited first!");
10277 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_route_hints(ptr);
10278 return nativeResponseValue;
10281 export function LDKPayee_Blinded_get_features(ptr: bigint): bigint {
10282 if(!isWasmInitialized) {
10283 throw new Error("initializeWasm() must be awaited first!");
10285 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_features(ptr);
10286 return nativeResponseValue;
10289 export function LDKPayee_Clear_get_node_id(ptr: bigint): number {
10290 if(!isWasmInitialized) {
10291 throw new Error("initializeWasm() must be awaited first!");
10293 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_node_id(ptr);
10294 return nativeResponseValue;
10297 export function LDKPayee_Clear_get_route_hints(ptr: bigint): number {
10298 if(!isWasmInitialized) {
10299 throw new Error("initializeWasm() must be awaited first!");
10301 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_route_hints(ptr);
10302 return nativeResponseValue;
10305 export function LDKPayee_Clear_get_features(ptr: bigint): bigint {
10306 if(!isWasmInitialized) {
10307 throw new Error("initializeWasm() must be awaited first!");
10309 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_features(ptr);
10310 return nativeResponseValue;
10313 export function LDKPayee_Clear_get_final_cltv_expiry_delta(ptr: bigint): number {
10314 if(!isWasmInitialized) {
10315 throw new Error("initializeWasm() must be awaited first!");
10317 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_final_cltv_expiry_delta(ptr);
10318 return nativeResponseValue;
10321 export interface LDKScore {
10326 export function LDKScore_new(impl: LDKScore, ScoreLookUp: number, ScoreUpdate: number): [bigint, number] {
10327 if(!isWasmInitialized) {
10328 throw new Error("initializeWasm() must be awaited first!");
10330 var new_obj_idx = js_objs.length;
10331 for (var i = 0; i < js_objs.length; i++) {
10332 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10334 js_objs[i] = new WeakRef(impl);
10335 return [wasm.TS_LDKScore_new(i, ScoreLookUp, ScoreUpdate), i];
10337 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
10339 export function Score_write(this_arg: bigint): number {
10340 if(!isWasmInitialized) {
10341 throw new Error("initializeWasm() must be awaited first!");
10343 const nativeResponseValue = wasm.TS_Score_write(this_arg);
10344 return nativeResponseValue;
10347 export class LDKDestination {
10348 protected constructor() {}
10351 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
10352 if(!isWasmInitialized) {
10353 throw new Error("initializeWasm() must be awaited first!");
10355 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
10356 return nativeResponseValue;
10359 export function LDKDestination_Node_get_node(ptr: bigint): number {
10360 if(!isWasmInitialized) {
10361 throw new Error("initializeWasm() must be awaited first!");
10363 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
10364 return nativeResponseValue;
10367 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
10368 if(!isWasmInitialized) {
10369 throw new Error("initializeWasm() must be awaited first!");
10371 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
10372 return nativeResponseValue;
10375 export interface LDKMessageRouter {
10376 find_path (sender: number, peers: number, destination: bigint): bigint;
10380 export function LDKMessageRouter_new(impl: LDKMessageRouter): [bigint, number] {
10381 if(!isWasmInitialized) {
10382 throw new Error("initializeWasm() must be awaited first!");
10384 var new_obj_idx = js_objs.length;
10385 for (var i = 0; i < js_objs.length; i++) {
10386 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10388 js_objs[i] = new WeakRef(impl);
10389 return [wasm.TS_LDKMessageRouter_new(i), i];
10391 // LDKCResult_OnionMessagePathNoneZ MessageRouter_find_path LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination
10393 export function MessageRouter_find_path(this_arg: bigint, sender: number, peers: number, destination: bigint): bigint {
10394 if(!isWasmInitialized) {
10395 throw new Error("initializeWasm() must be awaited first!");
10397 const nativeResponseValue = wasm.TS_MessageRouter_find_path(this_arg, sender, peers, destination);
10398 return nativeResponseValue;
10401 export class LDKOnionMessageContents {
10402 protected constructor() {}
10405 export function LDKOnionMessageContents_ty_from_ptr(ptr: bigint): number {
10406 if(!isWasmInitialized) {
10407 throw new Error("initializeWasm() must be awaited first!");
10409 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_ty_from_ptr(ptr);
10410 return nativeResponseValue;
10413 export function LDKOnionMessageContents_Offers_get_offers(ptr: bigint): bigint {
10414 if(!isWasmInitialized) {
10415 throw new Error("initializeWasm() must be awaited first!");
10417 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_Offers_get_offers(ptr);
10418 return nativeResponseValue;
10421 export function LDKOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
10422 if(!isWasmInitialized) {
10423 throw new Error("initializeWasm() must be awaited first!");
10425 const nativeResponseValue = wasm.TS_LDKOnionMessageContents_Custom_get_custom(ptr);
10426 return nativeResponseValue;
10429 export interface LDKCoinSelectionSource {
10430 select_confirmed_utxos (claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint;
10431 sign_tx (tx: number): bigint;
10435 export function LDKCoinSelectionSource_new(impl: LDKCoinSelectionSource): [bigint, number] {
10436 if(!isWasmInitialized) {
10437 throw new Error("initializeWasm() must be awaited first!");
10439 var new_obj_idx = js_objs.length;
10440 for (var i = 0; i < js_objs.length; i++) {
10441 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10443 js_objs[i] = new WeakRef(impl);
10444 return [wasm.TS_LDKCoinSelectionSource_new(i), i];
10446 // 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
10448 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 {
10449 if(!isWasmInitialized) {
10450 throw new Error("initializeWasm() must be awaited first!");
10452 const nativeResponseValue = wasm.TS_CoinSelectionSource_select_confirmed_utxos(this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
10453 return nativeResponseValue;
10455 // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_tx LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKTransaction tx
10457 export function CoinSelectionSource_sign_tx(this_arg: bigint, tx: number): bigint {
10458 if(!isWasmInitialized) {
10459 throw new Error("initializeWasm() must be awaited first!");
10461 const nativeResponseValue = wasm.TS_CoinSelectionSource_sign_tx(this_arg, tx);
10462 return nativeResponseValue;
10465 export interface LDKWalletSource {
10466 list_confirmed_utxos (): bigint;
10467 get_change_script (): bigint;
10468 sign_tx (tx: number): bigint;
10472 export function LDKWalletSource_new(impl: LDKWalletSource): [bigint, number] {
10473 if(!isWasmInitialized) {
10474 throw new Error("initializeWasm() must be awaited first!");
10476 var new_obj_idx = js_objs.length;
10477 for (var i = 0; i < js_objs.length; i++) {
10478 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10480 js_objs[i] = new WeakRef(impl);
10481 return [wasm.TS_LDKWalletSource_new(i), i];
10483 // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
10485 export function WalletSource_list_confirmed_utxos(this_arg: bigint): bigint {
10486 if(!isWasmInitialized) {
10487 throw new Error("initializeWasm() must be awaited first!");
10489 const nativeResponseValue = wasm.TS_WalletSource_list_confirmed_utxos(this_arg);
10490 return nativeResponseValue;
10492 // LDKCResult_CVec_u8ZNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
10494 export function WalletSource_get_change_script(this_arg: bigint): bigint {
10495 if(!isWasmInitialized) {
10496 throw new Error("initializeWasm() must be awaited first!");
10498 const nativeResponseValue = wasm.TS_WalletSource_get_change_script(this_arg);
10499 return nativeResponseValue;
10501 // LDKCResult_TransactionNoneZ WalletSource_sign_tx LDKWalletSource *NONNULL_PTR this_arg, struct LDKTransaction tx
10503 export function WalletSource_sign_tx(this_arg: bigint, tx: number): bigint {
10504 if(!isWasmInitialized) {
10505 throw new Error("initializeWasm() must be awaited first!");
10507 const nativeResponseValue = wasm.TS_WalletSource_sign_tx(this_arg, tx);
10508 return nativeResponseValue;
10511 export class LDKGossipSync {
10512 protected constructor() {}
10515 export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
10516 if(!isWasmInitialized) {
10517 throw new Error("initializeWasm() must be awaited first!");
10519 const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
10520 return nativeResponseValue;
10523 export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
10524 if(!isWasmInitialized) {
10525 throw new Error("initializeWasm() must be awaited first!");
10527 const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
10528 return nativeResponseValue;
10531 export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
10532 if(!isWasmInitialized) {
10533 throw new Error("initializeWasm() must be awaited first!");
10535 const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
10536 return nativeResponseValue;
10539 export class LDKFallback {
10540 protected constructor() {}
10543 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
10544 if(!isWasmInitialized) {
10545 throw new Error("initializeWasm() must be awaited first!");
10547 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
10548 return nativeResponseValue;
10551 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
10552 if(!isWasmInitialized) {
10553 throw new Error("initializeWasm() must be awaited first!");
10555 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
10556 return nativeResponseValue;
10559 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
10560 if(!isWasmInitialized) {
10561 throw new Error("initializeWasm() must be awaited first!");
10563 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
10564 return nativeResponseValue;
10567 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
10568 if(!isWasmInitialized) {
10569 throw new Error("initializeWasm() must be awaited first!");
10571 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
10572 return nativeResponseValue;
10575 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
10576 if(!isWasmInitialized) {
10577 throw new Error("initializeWasm() must be awaited first!");
10579 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
10580 return nativeResponseValue;
10582 // struct LDKStr _ldk_get_compiled_version(void);
10584 export function _ldk_get_compiled_version(): number {
10585 if(!isWasmInitialized) {
10586 throw new Error("initializeWasm() must be awaited first!");
10588 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
10589 return nativeResponseValue;
10591 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
10593 export function _ldk_c_bindings_get_compiled_version(): number {
10594 if(!isWasmInitialized) {
10595 throw new Error("initializeWasm() must be awaited first!");
10597 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
10598 return nativeResponseValue;
10600 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
10602 export function U128_le_bytes(val: number): number {
10603 if(!isWasmInitialized) {
10604 throw new Error("initializeWasm() must be awaited first!");
10606 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
10607 return nativeResponseValue;
10609 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
10611 export function U128_new(le_bytes: number): number {
10612 if(!isWasmInitialized) {
10613 throw new Error("initializeWasm() must be awaited first!");
10615 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
10616 return nativeResponseValue;
10618 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
10620 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
10621 if(!isWasmInitialized) {
10622 throw new Error("initializeWasm() must be awaited first!");
10624 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
10625 return nativeResponseValue;
10627 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
10629 export function Bech32Error_clone_ptr(arg: bigint): bigint {
10630 if(!isWasmInitialized) {
10631 throw new Error("initializeWasm() must be awaited first!");
10633 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
10634 return nativeResponseValue;
10636 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
10638 export function Bech32Error_clone(orig: bigint): bigint {
10639 if(!isWasmInitialized) {
10640 throw new Error("initializeWasm() must be awaited first!");
10642 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
10643 return nativeResponseValue;
10645 // void Bech32Error_free(struct LDKBech32Error o);
10647 export function Bech32Error_free(o: bigint): void {
10648 if(!isWasmInitialized) {
10649 throw new Error("initializeWasm() must be awaited first!");
10651 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
10652 // debug statements here
10654 // void Transaction_free(struct LDKTransaction _res);
10656 export function Transaction_free(_res: number): void {
10657 if(!isWasmInitialized) {
10658 throw new Error("initializeWasm() must be awaited first!");
10660 const nativeResponseValue = wasm.TS_Transaction_free(_res);
10661 // debug statements here
10663 // void Witness_free(struct LDKWitness _res);
10665 export function Witness_free(_res: number): void {
10666 if(!isWasmInitialized) {
10667 throw new Error("initializeWasm() must be awaited first!");
10669 const nativeResponseValue = wasm.TS_Witness_free(_res);
10670 // debug statements here
10672 // void TxIn_free(struct LDKTxIn _res);
10674 export function TxIn_free(_res: bigint): void {
10675 if(!isWasmInitialized) {
10676 throw new Error("initializeWasm() must be awaited first!");
10678 const nativeResponseValue = wasm.TS_TxIn_free(_res);
10679 // debug statements here
10681 // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
10683 export function TxIn_new(witness: number, script_sig: number, sequence: number, previous_txid: number, previous_vout: number): bigint {
10684 if(!isWasmInitialized) {
10685 throw new Error("initializeWasm() must be awaited first!");
10687 const nativeResponseValue = wasm.TS_TxIn_new(witness, script_sig, sequence, previous_txid, previous_vout);
10688 return nativeResponseValue;
10690 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
10692 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
10693 if(!isWasmInitialized) {
10694 throw new Error("initializeWasm() must be awaited first!");
10696 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
10697 return nativeResponseValue;
10699 // void TxOut_free(struct LDKTxOut _res);
10701 export function TxOut_free(_res: bigint): void {
10702 if(!isWasmInitialized) {
10703 throw new Error("initializeWasm() must be awaited first!");
10705 const nativeResponseValue = wasm.TS_TxOut_free(_res);
10706 // debug statements here
10708 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
10710 export function TxOut_clone_ptr(arg: bigint): bigint {
10711 if(!isWasmInitialized) {
10712 throw new Error("initializeWasm() must be awaited first!");
10714 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
10715 return nativeResponseValue;
10717 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
10719 export function TxOut_clone(orig: bigint): bigint {
10720 if(!isWasmInitialized) {
10721 throw new Error("initializeWasm() must be awaited first!");
10723 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
10724 return nativeResponseValue;
10726 // void Str_free(struct LDKStr _res);
10728 export function Str_free(_res: number): void {
10729 if(!isWasmInitialized) {
10730 throw new Error("initializeWasm() must be awaited first!");
10732 const nativeResponseValue = wasm.TS_Str_free(_res);
10733 // debug statements here
10735 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
10737 export function COption_u64Z_some(o: bigint): bigint {
10738 if(!isWasmInitialized) {
10739 throw new Error("initializeWasm() must be awaited first!");
10741 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
10742 return nativeResponseValue;
10744 // struct LDKCOption_u64Z COption_u64Z_none(void);
10746 export function COption_u64Z_none(): bigint {
10747 if(!isWasmInitialized) {
10748 throw new Error("initializeWasm() must be awaited first!");
10750 const nativeResponseValue = wasm.TS_COption_u64Z_none();
10751 return nativeResponseValue;
10753 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
10755 export function COption_u64Z_free(_res: bigint): void {
10756 if(!isWasmInitialized) {
10757 throw new Error("initializeWasm() must be awaited first!");
10759 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
10760 // debug statements here
10762 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
10764 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
10765 if(!isWasmInitialized) {
10766 throw new Error("initializeWasm() must be awaited first!");
10768 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
10769 return nativeResponseValue;
10771 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
10773 export function COption_u64Z_clone(orig: bigint): bigint {
10774 if(!isWasmInitialized) {
10775 throw new Error("initializeWasm() must be awaited first!");
10777 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
10778 return nativeResponseValue;
10780 // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
10782 export function CVec_BlindedPathZ_free(_res: number): void {
10783 if(!isWasmInitialized) {
10784 throw new Error("initializeWasm() must be awaited first!");
10786 const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
10787 // debug statements here
10789 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
10791 export function CResult_RefundBolt12ParseErrorZ_ok(o: bigint): bigint {
10792 if(!isWasmInitialized) {
10793 throw new Error("initializeWasm() must be awaited first!");
10795 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_ok(o);
10796 return nativeResponseValue;
10798 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
10800 export function CResult_RefundBolt12ParseErrorZ_err(e: bigint): bigint {
10801 if(!isWasmInitialized) {
10802 throw new Error("initializeWasm() must be awaited first!");
10804 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_err(e);
10805 return nativeResponseValue;
10807 // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
10809 export function CResult_RefundBolt12ParseErrorZ_is_ok(o: bigint): boolean {
10810 if(!isWasmInitialized) {
10811 throw new Error("initializeWasm() must be awaited first!");
10813 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_is_ok(o);
10814 return nativeResponseValue;
10816 // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
10818 export function CResult_RefundBolt12ParseErrorZ_free(_res: bigint): void {
10819 if(!isWasmInitialized) {
10820 throw new Error("initializeWasm() must be awaited first!");
10822 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_free(_res);
10823 // debug statements here
10825 // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
10827 export function CResult_RefundBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
10828 if(!isWasmInitialized) {
10829 throw new Error("initializeWasm() must be awaited first!");
10831 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(arg);
10832 return nativeResponseValue;
10834 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
10836 export function CResult_RefundBolt12ParseErrorZ_clone(orig: bigint): bigint {
10837 if(!isWasmInitialized) {
10838 throw new Error("initializeWasm() must be awaited first!");
10840 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone(orig);
10841 return nativeResponseValue;
10843 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_ok(struct LDKRetry o);
10845 export function CResult_RetryDecodeErrorZ_ok(o: bigint): bigint {
10846 if(!isWasmInitialized) {
10847 throw new Error("initializeWasm() must be awaited first!");
10849 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_ok(o);
10850 return nativeResponseValue;
10852 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_err(struct LDKDecodeError e);
10854 export function CResult_RetryDecodeErrorZ_err(e: bigint): bigint {
10855 if(!isWasmInitialized) {
10856 throw new Error("initializeWasm() must be awaited first!");
10858 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_err(e);
10859 return nativeResponseValue;
10861 // bool CResult_RetryDecodeErrorZ_is_ok(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR o);
10863 export function CResult_RetryDecodeErrorZ_is_ok(o: bigint): boolean {
10864 if(!isWasmInitialized) {
10865 throw new Error("initializeWasm() must be awaited first!");
10867 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_is_ok(o);
10868 return nativeResponseValue;
10870 // void CResult_RetryDecodeErrorZ_free(struct LDKCResult_RetryDecodeErrorZ _res);
10872 export function CResult_RetryDecodeErrorZ_free(_res: bigint): void {
10873 if(!isWasmInitialized) {
10874 throw new Error("initializeWasm() must be awaited first!");
10876 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_free(_res);
10877 // debug statements here
10879 // uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg);
10881 export function CResult_RetryDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10882 if(!isWasmInitialized) {
10883 throw new Error("initializeWasm() must be awaited first!");
10885 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone_ptr(arg);
10886 return nativeResponseValue;
10888 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_clone(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR orig);
10890 export function CResult_RetryDecodeErrorZ_clone(orig: bigint): bigint {
10891 if(!isWasmInitialized) {
10892 throw new Error("initializeWasm() must be awaited first!");
10894 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone(orig);
10895 return nativeResponseValue;
10897 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10899 export function CResult_NoneAPIErrorZ_ok(): bigint {
10900 if(!isWasmInitialized) {
10901 throw new Error("initializeWasm() must be awaited first!");
10903 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10904 return nativeResponseValue;
10906 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10908 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
10909 if(!isWasmInitialized) {
10910 throw new Error("initializeWasm() must be awaited first!");
10912 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10913 return nativeResponseValue;
10915 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10917 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
10918 if(!isWasmInitialized) {
10919 throw new Error("initializeWasm() must be awaited first!");
10921 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10922 return nativeResponseValue;
10924 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10926 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
10927 if(!isWasmInitialized) {
10928 throw new Error("initializeWasm() must be awaited first!");
10930 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
10931 // debug statements here
10933 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
10935 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
10936 if(!isWasmInitialized) {
10937 throw new Error("initializeWasm() must be awaited first!");
10939 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
10940 return nativeResponseValue;
10942 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
10944 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
10945 if(!isWasmInitialized) {
10946 throw new Error("initializeWasm() must be awaited first!");
10948 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
10949 return nativeResponseValue;
10951 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
10953 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
10954 if(!isWasmInitialized) {
10955 throw new Error("initializeWasm() must be awaited first!");
10957 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
10958 // debug statements here
10960 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
10962 export function CVec_APIErrorZ_free(_res: number): void {
10963 if(!isWasmInitialized) {
10964 throw new Error("initializeWasm() must be awaited first!");
10966 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
10967 // debug statements here
10969 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_some(struct LDKThirtyTwoBytes o);
10971 export function COption_ThirtyTwoBytesZ_some(o: number): bigint {
10972 if(!isWasmInitialized) {
10973 throw new Error("initializeWasm() must be awaited first!");
10975 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_some(o);
10976 return nativeResponseValue;
10978 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_none(void);
10980 export function COption_ThirtyTwoBytesZ_none(): bigint {
10981 if(!isWasmInitialized) {
10982 throw new Error("initializeWasm() must be awaited first!");
10984 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_none();
10985 return nativeResponseValue;
10987 // void COption_ThirtyTwoBytesZ_free(struct LDKCOption_ThirtyTwoBytesZ _res);
10989 export function COption_ThirtyTwoBytesZ_free(_res: bigint): void {
10990 if(!isWasmInitialized) {
10991 throw new Error("initializeWasm() must be awaited first!");
10993 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_free(_res);
10994 // debug statements here
10996 // uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg);
10998 export function COption_ThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
10999 if(!isWasmInitialized) {
11000 throw new Error("initializeWasm() must be awaited first!");
11002 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone_ptr(arg);
11003 return nativeResponseValue;
11005 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_clone(const struct LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR orig);
11007 export function COption_ThirtyTwoBytesZ_clone(orig: bigint): bigint {
11008 if(!isWasmInitialized) {
11009 throw new Error("initializeWasm() must be awaited first!");
11011 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone(orig);
11012 return nativeResponseValue;
11014 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
11016 export function CVec_u8Z_free(_res: number): void {
11017 if(!isWasmInitialized) {
11018 throw new Error("initializeWasm() must be awaited first!");
11020 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
11021 // debug statements here
11023 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
11025 export function COption_CVec_u8ZZ_some(o: number): bigint {
11026 if(!isWasmInitialized) {
11027 throw new Error("initializeWasm() must be awaited first!");
11029 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
11030 return nativeResponseValue;
11032 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
11034 export function COption_CVec_u8ZZ_none(): bigint {
11035 if(!isWasmInitialized) {
11036 throw new Error("initializeWasm() must be awaited first!");
11038 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
11039 return nativeResponseValue;
11041 // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
11043 export function COption_CVec_u8ZZ_free(_res: bigint): void {
11044 if(!isWasmInitialized) {
11045 throw new Error("initializeWasm() must be awaited first!");
11047 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
11048 // debug statements here
11050 // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
11052 export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
11053 if(!isWasmInitialized) {
11054 throw new Error("initializeWasm() must be awaited first!");
11056 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
11057 return nativeResponseValue;
11059 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
11061 export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
11062 if(!isWasmInitialized) {
11063 throw new Error("initializeWasm() must be awaited first!");
11065 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
11066 return nativeResponseValue;
11068 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
11070 export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
11071 if(!isWasmInitialized) {
11072 throw new Error("initializeWasm() must be awaited first!");
11074 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
11075 return nativeResponseValue;
11077 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
11079 export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
11080 if(!isWasmInitialized) {
11081 throw new Error("initializeWasm() must be awaited first!");
11083 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
11084 return nativeResponseValue;
11086 // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
11088 export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
11089 if(!isWasmInitialized) {
11090 throw new Error("initializeWasm() must be awaited first!");
11092 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
11093 return nativeResponseValue;
11095 // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
11097 export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
11098 if(!isWasmInitialized) {
11099 throw new Error("initializeWasm() must be awaited first!");
11101 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
11102 // debug statements here
11104 // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
11106 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11107 if(!isWasmInitialized) {
11108 throw new Error("initializeWasm() must be awaited first!");
11110 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
11111 return nativeResponseValue;
11113 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
11115 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
11116 if(!isWasmInitialized) {
11117 throw new Error("initializeWasm() must be awaited first!");
11119 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
11120 return nativeResponseValue;
11122 // uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg);
11124 export function C2Tuple_u64CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
11125 if(!isWasmInitialized) {
11126 throw new Error("initializeWasm() must be awaited first!");
11128 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone_ptr(arg);
11129 return nativeResponseValue;
11131 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_clone(const struct LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR orig);
11133 export function C2Tuple_u64CVec_u8ZZ_clone(orig: bigint): bigint {
11134 if(!isWasmInitialized) {
11135 throw new Error("initializeWasm() must be awaited first!");
11137 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone(orig);
11138 return nativeResponseValue;
11140 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_new(uint64_t a, struct LDKCVec_u8Z b);
11142 export function C2Tuple_u64CVec_u8ZZ_new(a: bigint, b: number): bigint {
11143 if(!isWasmInitialized) {
11144 throw new Error("initializeWasm() must be awaited first!");
11146 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_new(a, b);
11147 return nativeResponseValue;
11149 // void C2Tuple_u64CVec_u8ZZ_free(struct LDKC2Tuple_u64CVec_u8ZZ _res);
11151 export function C2Tuple_u64CVec_u8ZZ_free(_res: bigint): void {
11152 if(!isWasmInitialized) {
11153 throw new Error("initializeWasm() must be awaited first!");
11155 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_free(_res);
11156 // debug statements here
11158 // void CVec_C2Tuple_u64CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u64CVec_u8ZZZ _res);
11160 export function CVec_C2Tuple_u64CVec_u8ZZZ_free(_res: number): void {
11161 if(!isWasmInitialized) {
11162 throw new Error("initializeWasm() must be awaited first!");
11164 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u64CVec_u8ZZZ_free(_res);
11165 // debug statements here
11167 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_ok(struct LDKRecipientOnionFields o);
11169 export function CResult_RecipientOnionFieldsNoneZ_ok(o: bigint): bigint {
11170 if(!isWasmInitialized) {
11171 throw new Error("initializeWasm() must be awaited first!");
11173 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_ok(o);
11174 return nativeResponseValue;
11176 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_err(void);
11178 export function CResult_RecipientOnionFieldsNoneZ_err(): bigint {
11179 if(!isWasmInitialized) {
11180 throw new Error("initializeWasm() must be awaited first!");
11182 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_err();
11183 return nativeResponseValue;
11185 // bool CResult_RecipientOnionFieldsNoneZ_is_ok(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR o);
11187 export function CResult_RecipientOnionFieldsNoneZ_is_ok(o: bigint): boolean {
11188 if(!isWasmInitialized) {
11189 throw new Error("initializeWasm() must be awaited first!");
11191 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_is_ok(o);
11192 return nativeResponseValue;
11194 // void CResult_RecipientOnionFieldsNoneZ_free(struct LDKCResult_RecipientOnionFieldsNoneZ _res);
11196 export function CResult_RecipientOnionFieldsNoneZ_free(_res: bigint): void {
11197 if(!isWasmInitialized) {
11198 throw new Error("initializeWasm() must be awaited first!");
11200 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_free(_res);
11201 // debug statements here
11203 // uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg);
11205 export function CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg: bigint): bigint {
11206 if(!isWasmInitialized) {
11207 throw new Error("initializeWasm() must be awaited first!");
11209 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg);
11210 return nativeResponseValue;
11212 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_clone(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR orig);
11214 export function CResult_RecipientOnionFieldsNoneZ_clone(orig: bigint): bigint {
11215 if(!isWasmInitialized) {
11216 throw new Error("initializeWasm() must be awaited first!");
11218 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone(orig);
11219 return nativeResponseValue;
11221 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
11223 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
11224 if(!isWasmInitialized) {
11225 throw new Error("initializeWasm() must be awaited first!");
11227 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
11228 // debug statements here
11230 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_some(struct LDKCVec_ThirtyTwoBytesZ o);
11232 export function COption_CVec_ThirtyTwoBytesZZ_some(o: number): bigint {
11233 if(!isWasmInitialized) {
11234 throw new Error("initializeWasm() must be awaited first!");
11236 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_some(o);
11237 return nativeResponseValue;
11239 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_none(void);
11241 export function COption_CVec_ThirtyTwoBytesZZ_none(): bigint {
11242 if(!isWasmInitialized) {
11243 throw new Error("initializeWasm() must be awaited first!");
11245 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_none();
11246 return nativeResponseValue;
11248 // void COption_CVec_ThirtyTwoBytesZZ_free(struct LDKCOption_CVec_ThirtyTwoBytesZZ _res);
11250 export function COption_CVec_ThirtyTwoBytesZZ_free(_res: bigint): void {
11251 if(!isWasmInitialized) {
11252 throw new Error("initializeWasm() must be awaited first!");
11254 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_free(_res);
11255 // debug statements here
11257 // uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg);
11259 export function COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
11260 if(!isWasmInitialized) {
11261 throw new Error("initializeWasm() must be awaited first!");
11263 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg);
11264 return nativeResponseValue;
11266 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_clone(const struct LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR orig);
11268 export function COption_CVec_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
11269 if(!isWasmInitialized) {
11270 throw new Error("initializeWasm() must be awaited first!");
11272 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone(orig);
11273 return nativeResponseValue;
11275 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_ok(struct LDKThirtyTwoBytes o);
11277 export function CResult_ThirtyTwoBytesNoneZ_ok(o: number): bigint {
11278 if(!isWasmInitialized) {
11279 throw new Error("initializeWasm() must be awaited first!");
11281 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_ok(o);
11282 return nativeResponseValue;
11284 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_err(void);
11286 export function CResult_ThirtyTwoBytesNoneZ_err(): bigint {
11287 if(!isWasmInitialized) {
11288 throw new Error("initializeWasm() must be awaited first!");
11290 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_err();
11291 return nativeResponseValue;
11293 // bool CResult_ThirtyTwoBytesNoneZ_is_ok(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR o);
11295 export function CResult_ThirtyTwoBytesNoneZ_is_ok(o: bigint): boolean {
11296 if(!isWasmInitialized) {
11297 throw new Error("initializeWasm() must be awaited first!");
11299 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_is_ok(o);
11300 return nativeResponseValue;
11302 // void CResult_ThirtyTwoBytesNoneZ_free(struct LDKCResult_ThirtyTwoBytesNoneZ _res);
11304 export function CResult_ThirtyTwoBytesNoneZ_free(_res: bigint): void {
11305 if(!isWasmInitialized) {
11306 throw new Error("initializeWasm() must be awaited first!");
11308 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_free(_res);
11309 // debug statements here
11311 // uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg);
11313 export function CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg: bigint): bigint {
11314 if(!isWasmInitialized) {
11315 throw new Error("initializeWasm() must be awaited first!");
11317 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg);
11318 return nativeResponseValue;
11320 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_clone(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR orig);
11322 export function CResult_ThirtyTwoBytesNoneZ_clone(orig: bigint): bigint {
11323 if(!isWasmInitialized) {
11324 throw new Error("initializeWasm() must be awaited first!");
11326 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone(orig);
11327 return nativeResponseValue;
11329 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
11331 export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
11332 if(!isWasmInitialized) {
11333 throw new Error("initializeWasm() must be awaited first!");
11335 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
11336 return nativeResponseValue;
11338 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
11340 export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
11341 if(!isWasmInitialized) {
11342 throw new Error("initializeWasm() must be awaited first!");
11344 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
11345 return nativeResponseValue;
11347 // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
11349 export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11350 if(!isWasmInitialized) {
11351 throw new Error("initializeWasm() must be awaited first!");
11353 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
11354 return nativeResponseValue;
11356 // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
11358 export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
11359 if(!isWasmInitialized) {
11360 throw new Error("initializeWasm() must be awaited first!");
11362 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
11363 // debug statements here
11365 // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
11367 export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11368 if(!isWasmInitialized) {
11369 throw new Error("initializeWasm() must be awaited first!");
11371 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
11372 return nativeResponseValue;
11374 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
11376 export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
11377 if(!isWasmInitialized) {
11378 throw new Error("initializeWasm() must be awaited first!");
11380 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
11381 return nativeResponseValue;
11383 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
11385 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11386 if(!isWasmInitialized) {
11387 throw new Error("initializeWasm() must be awaited first!");
11389 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
11390 return nativeResponseValue;
11392 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11394 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11395 if(!isWasmInitialized) {
11396 throw new Error("initializeWasm() must be awaited first!");
11398 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
11399 return nativeResponseValue;
11401 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11403 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11404 if(!isWasmInitialized) {
11405 throw new Error("initializeWasm() must be awaited first!");
11407 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11408 return nativeResponseValue;
11410 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
11412 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11413 if(!isWasmInitialized) {
11414 throw new Error("initializeWasm() must be awaited first!");
11416 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
11417 // debug statements here
11419 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11421 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11422 if(!isWasmInitialized) {
11423 throw new Error("initializeWasm() must be awaited first!");
11425 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11426 return nativeResponseValue;
11428 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11430 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11431 if(!isWasmInitialized) {
11432 throw new Error("initializeWasm() must be awaited first!");
11434 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11435 return nativeResponseValue;
11437 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
11439 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11440 if(!isWasmInitialized) {
11441 throw new Error("initializeWasm() must be awaited first!");
11443 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
11444 return nativeResponseValue;
11446 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11448 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11449 if(!isWasmInitialized) {
11450 throw new Error("initializeWasm() must be awaited first!");
11452 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
11453 return nativeResponseValue;
11455 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11457 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11458 if(!isWasmInitialized) {
11459 throw new Error("initializeWasm() must be awaited first!");
11461 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11462 return nativeResponseValue;
11464 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
11466 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11467 if(!isWasmInitialized) {
11468 throw new Error("initializeWasm() must be awaited first!");
11470 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
11471 // debug statements here
11473 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11475 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11476 if(!isWasmInitialized) {
11477 throw new Error("initializeWasm() must be awaited first!");
11479 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11480 return nativeResponseValue;
11482 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11484 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11485 if(!isWasmInitialized) {
11486 throw new Error("initializeWasm() must be awaited first!");
11488 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11489 return nativeResponseValue;
11491 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
11493 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11494 if(!isWasmInitialized) {
11495 throw new Error("initializeWasm() must be awaited first!");
11497 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
11498 return nativeResponseValue;
11500 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11502 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11503 if(!isWasmInitialized) {
11504 throw new Error("initializeWasm() must be awaited first!");
11506 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
11507 return nativeResponseValue;
11509 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11511 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11512 if(!isWasmInitialized) {
11513 throw new Error("initializeWasm() must be awaited first!");
11515 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
11516 return nativeResponseValue;
11518 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
11520 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11521 if(!isWasmInitialized) {
11522 throw new Error("initializeWasm() must be awaited first!");
11524 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
11525 // debug statements here
11527 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11529 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11530 if(!isWasmInitialized) {
11531 throw new Error("initializeWasm() must be awaited first!");
11533 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11534 return nativeResponseValue;
11536 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11538 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11539 if(!isWasmInitialized) {
11540 throw new Error("initializeWasm() must be awaited first!");
11542 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
11543 return nativeResponseValue;
11545 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
11547 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
11548 if(!isWasmInitialized) {
11549 throw new Error("initializeWasm() must be awaited first!");
11551 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
11552 // debug statements here
11554 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11556 export function CVec_TxOutZ_free(_res: number): void {
11557 if(!isWasmInitialized) {
11558 throw new Error("initializeWasm() must be awaited first!");
11560 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11561 // debug statements here
11563 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
11565 export function COption_u32Z_some(o: number): bigint {
11566 if(!isWasmInitialized) {
11567 throw new Error("initializeWasm() must be awaited first!");
11569 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
11570 return nativeResponseValue;
11572 // struct LDKCOption_u32Z COption_u32Z_none(void);
11574 export function COption_u32Z_none(): bigint {
11575 if(!isWasmInitialized) {
11576 throw new Error("initializeWasm() must be awaited first!");
11578 const nativeResponseValue = wasm.TS_COption_u32Z_none();
11579 return nativeResponseValue;
11581 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
11583 export function COption_u32Z_free(_res: bigint): void {
11584 if(!isWasmInitialized) {
11585 throw new Error("initializeWasm() must be awaited first!");
11587 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
11588 // debug statements here
11590 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
11592 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
11593 if(!isWasmInitialized) {
11594 throw new Error("initializeWasm() must be awaited first!");
11596 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
11597 return nativeResponseValue;
11599 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
11601 export function COption_u32Z_clone(orig: bigint): bigint {
11602 if(!isWasmInitialized) {
11603 throw new Error("initializeWasm() must be awaited first!");
11605 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
11606 return nativeResponseValue;
11608 // uint64_t C2Tuple_CVec_u8ZusizeZ_clone_ptr(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR arg);
11610 export function C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg: bigint): bigint {
11611 if(!isWasmInitialized) {
11612 throw new Error("initializeWasm() must be awaited first!");
11614 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg);
11615 return nativeResponseValue;
11617 // struct LDKC2Tuple_CVec_u8ZusizeZ C2Tuple_CVec_u8ZusizeZ_clone(const struct LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR orig);
11619 export function C2Tuple_CVec_u8ZusizeZ_clone(orig: bigint): bigint {
11620 if(!isWasmInitialized) {
11621 throw new Error("initializeWasm() must be awaited first!");
11623 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_clone(orig);
11624 return nativeResponseValue;
11626 // struct LDKC2Tuple_CVec_u8ZusizeZ C2Tuple_CVec_u8ZusizeZ_new(struct LDKCVec_u8Z a, uintptr_t b);
11628 export function C2Tuple_CVec_u8ZusizeZ_new(a: number, b: number): bigint {
11629 if(!isWasmInitialized) {
11630 throw new Error("initializeWasm() must be awaited first!");
11632 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_new(a, b);
11633 return nativeResponseValue;
11635 // void C2Tuple_CVec_u8ZusizeZ_free(struct LDKC2Tuple_CVec_u8ZusizeZ _res);
11637 export function C2Tuple_CVec_u8ZusizeZ_free(_res: bigint): void {
11638 if(!isWasmInitialized) {
11639 throw new Error("initializeWasm() must be awaited first!");
11641 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_free(_res);
11642 // debug statements here
11644 // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(struct LDKC2Tuple_CVec_u8ZusizeZ o);
11646 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o: bigint): bigint {
11647 if(!isWasmInitialized) {
11648 throw new Error("initializeWasm() must be awaited first!");
11650 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o);
11651 return nativeResponseValue;
11653 // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err(void);
11655 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err(): bigint {
11656 if(!isWasmInitialized) {
11657 throw new Error("initializeWasm() must be awaited first!");
11659 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err();
11660 return nativeResponseValue;
11662 // bool CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(const struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR o);
11664 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o: bigint): boolean {
11665 if(!isWasmInitialized) {
11666 throw new Error("initializeWasm() must be awaited first!");
11668 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o);
11669 return nativeResponseValue;
11671 // void CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ _res);
11673 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res: bigint): void {
11674 if(!isWasmInitialized) {
11675 throw new Error("initializeWasm() must be awaited first!");
11677 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res);
11678 // debug statements here
11680 // uint64_t CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR arg);
11682 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg: bigint): bigint {
11683 if(!isWasmInitialized) {
11684 throw new Error("initializeWasm() must be awaited first!");
11686 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg);
11687 return nativeResponseValue;
11689 // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(const struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR orig);
11691 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig: bigint): bigint {
11692 if(!isWasmInitialized) {
11693 throw new Error("initializeWasm() must be awaited first!");
11695 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig);
11696 return nativeResponseValue;
11698 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
11700 export function CResult_NoneNoneZ_ok(): bigint {
11701 if(!isWasmInitialized) {
11702 throw new Error("initializeWasm() must be awaited first!");
11704 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
11705 return nativeResponseValue;
11707 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
11709 export function CResult_NoneNoneZ_err(): bigint {
11710 if(!isWasmInitialized) {
11711 throw new Error("initializeWasm() must be awaited first!");
11713 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
11714 return nativeResponseValue;
11716 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
11718 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
11719 if(!isWasmInitialized) {
11720 throw new Error("initializeWasm() must be awaited first!");
11722 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
11723 return nativeResponseValue;
11725 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
11727 export function CResult_NoneNoneZ_free(_res: bigint): void {
11728 if(!isWasmInitialized) {
11729 throw new Error("initializeWasm() must be awaited first!");
11731 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
11732 // debug statements here
11734 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
11736 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
11737 if(!isWasmInitialized) {
11738 throw new Error("initializeWasm() must be awaited first!");
11740 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
11741 return nativeResponseValue;
11743 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
11745 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
11746 if(!isWasmInitialized) {
11747 throw new Error("initializeWasm() must be awaited first!");
11749 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
11750 return nativeResponseValue;
11752 // void CVec_ECDSASignatureZ_free(struct LDKCVec_ECDSASignatureZ _res);
11754 export function CVec_ECDSASignatureZ_free(_res: number): void {
11755 if(!isWasmInitialized) {
11756 throw new Error("initializeWasm() must be awaited first!");
11758 const nativeResponseValue = wasm.TS_CVec_ECDSASignatureZ_free(_res);
11759 // debug statements here
11761 // uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg);
11763 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg: bigint): bigint {
11764 if(!isWasmInitialized) {
11765 throw new Error("initializeWasm() must be awaited first!");
11767 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg);
11768 return nativeResponseValue;
11770 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(const struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR orig);
11772 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig: bigint): bigint {
11773 if(!isWasmInitialized) {
11774 throw new Error("initializeWasm() must be awaited first!");
11776 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig);
11777 return nativeResponseValue;
11779 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(struct LDKECDSASignature a, struct LDKCVec_ECDSASignatureZ b);
11781 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a: number, b: number): bigint {
11782 if(!isWasmInitialized) {
11783 throw new Error("initializeWasm() must be awaited first!");
11785 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a, b);
11786 return nativeResponseValue;
11788 // void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res);
11790 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res: bigint): void {
11791 if(!isWasmInitialized) {
11792 throw new Error("initializeWasm() must be awaited first!");
11794 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res);
11795 // debug statements here
11797 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o);
11799 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o: bigint): bigint {
11800 if(!isWasmInitialized) {
11801 throw new Error("initializeWasm() must be awaited first!");
11803 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o);
11804 return nativeResponseValue;
11806 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(void);
11808 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(): bigint {
11809 if(!isWasmInitialized) {
11810 throw new Error("initializeWasm() must be awaited first!");
11812 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
11813 return nativeResponseValue;
11815 // bool CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR o);
11817 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o: bigint): boolean {
11818 if(!isWasmInitialized) {
11819 throw new Error("initializeWasm() must be awaited first!");
11821 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o);
11822 return nativeResponseValue;
11824 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res);
11826 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res: bigint): void {
11827 if(!isWasmInitialized) {
11828 throw new Error("initializeWasm() must be awaited first!");
11830 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res);
11831 // debug statements here
11833 // uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg);
11835 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
11836 if(!isWasmInitialized) {
11837 throw new Error("initializeWasm() must be awaited first!");
11839 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg);
11840 return nativeResponseValue;
11842 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR orig);
11844 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig: bigint): bigint {
11845 if(!isWasmInitialized) {
11846 throw new Error("initializeWasm() must be awaited first!");
11848 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig);
11849 return nativeResponseValue;
11851 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_ok(struct LDKECDSASignature o);
11853 export function CResult_ECDSASignatureNoneZ_ok(o: number): bigint {
11854 if(!isWasmInitialized) {
11855 throw new Error("initializeWasm() must be awaited first!");
11857 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_ok(o);
11858 return nativeResponseValue;
11860 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_err(void);
11862 export function CResult_ECDSASignatureNoneZ_err(): bigint {
11863 if(!isWasmInitialized) {
11864 throw new Error("initializeWasm() must be awaited first!");
11866 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_err();
11867 return nativeResponseValue;
11869 // bool CResult_ECDSASignatureNoneZ_is_ok(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR o);
11871 export function CResult_ECDSASignatureNoneZ_is_ok(o: bigint): boolean {
11872 if(!isWasmInitialized) {
11873 throw new Error("initializeWasm() must be awaited first!");
11875 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_is_ok(o);
11876 return nativeResponseValue;
11878 // void CResult_ECDSASignatureNoneZ_free(struct LDKCResult_ECDSASignatureNoneZ _res);
11880 export function CResult_ECDSASignatureNoneZ_free(_res: bigint): void {
11881 if(!isWasmInitialized) {
11882 throw new Error("initializeWasm() must be awaited first!");
11884 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_free(_res);
11885 // debug statements here
11887 // uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg);
11889 export function CResult_ECDSASignatureNoneZ_clone_ptr(arg: bigint): bigint {
11890 if(!isWasmInitialized) {
11891 throw new Error("initializeWasm() must be awaited first!");
11893 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone_ptr(arg);
11894 return nativeResponseValue;
11896 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_clone(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR orig);
11898 export function CResult_ECDSASignatureNoneZ_clone(orig: bigint): bigint {
11899 if(!isWasmInitialized) {
11900 throw new Error("initializeWasm() must be awaited first!");
11902 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone(orig);
11903 return nativeResponseValue;
11905 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
11907 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
11908 if(!isWasmInitialized) {
11909 throw new Error("initializeWasm() must be awaited first!");
11911 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
11912 return nativeResponseValue;
11914 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
11916 export function CResult_PublicKeyNoneZ_err(): bigint {
11917 if(!isWasmInitialized) {
11918 throw new Error("initializeWasm() must be awaited first!");
11920 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
11921 return nativeResponseValue;
11923 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
11925 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
11926 if(!isWasmInitialized) {
11927 throw new Error("initializeWasm() must be awaited first!");
11929 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
11930 return nativeResponseValue;
11932 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
11934 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
11935 if(!isWasmInitialized) {
11936 throw new Error("initializeWasm() must be awaited first!");
11938 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
11939 // debug statements here
11941 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
11943 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
11944 if(!isWasmInitialized) {
11945 throw new Error("initializeWasm() must be awaited first!");
11947 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
11948 return nativeResponseValue;
11950 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
11952 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
11953 if(!isWasmInitialized) {
11954 throw new Error("initializeWasm() must be awaited first!");
11956 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
11957 return nativeResponseValue;
11959 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_some(struct LDKBigEndianScalar o);
11961 export function COption_BigEndianScalarZ_some(o: bigint): bigint {
11962 if(!isWasmInitialized) {
11963 throw new Error("initializeWasm() must be awaited first!");
11965 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_some(o);
11966 return nativeResponseValue;
11968 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_none(void);
11970 export function COption_BigEndianScalarZ_none(): bigint {
11971 if(!isWasmInitialized) {
11972 throw new Error("initializeWasm() must be awaited first!");
11974 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_none();
11975 return nativeResponseValue;
11977 // void COption_BigEndianScalarZ_free(struct LDKCOption_BigEndianScalarZ _res);
11979 export function COption_BigEndianScalarZ_free(_res: bigint): void {
11980 if(!isWasmInitialized) {
11981 throw new Error("initializeWasm() must be awaited first!");
11983 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_free(_res);
11984 // debug statements here
11986 // uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg);
11988 export function COption_BigEndianScalarZ_clone_ptr(arg: bigint): bigint {
11989 if(!isWasmInitialized) {
11990 throw new Error("initializeWasm() must be awaited first!");
11992 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone_ptr(arg);
11993 return nativeResponseValue;
11995 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_clone(const struct LDKCOption_BigEndianScalarZ *NONNULL_PTR orig);
11997 export function COption_BigEndianScalarZ_clone(orig: bigint): bigint {
11998 if(!isWasmInitialized) {
11999 throw new Error("initializeWasm() must be awaited first!");
12001 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone(orig);
12002 return nativeResponseValue;
12004 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
12006 export function CVec_U5Z_free(_res: number): void {
12007 if(!isWasmInitialized) {
12008 throw new Error("initializeWasm() must be awaited first!");
12010 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
12011 // debug statements here
12013 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
12015 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
12016 if(!isWasmInitialized) {
12017 throw new Error("initializeWasm() must be awaited first!");
12019 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
12020 return nativeResponseValue;
12022 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
12024 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
12025 if(!isWasmInitialized) {
12026 throw new Error("initializeWasm() must be awaited first!");
12028 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
12029 return nativeResponseValue;
12031 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
12033 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
12034 if(!isWasmInitialized) {
12035 throw new Error("initializeWasm() must be awaited first!");
12037 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
12038 return nativeResponseValue;
12040 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
12042 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
12043 if(!isWasmInitialized) {
12044 throw new Error("initializeWasm() must be awaited first!");
12046 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
12047 // debug statements here
12049 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
12051 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12052 if(!isWasmInitialized) {
12053 throw new Error("initializeWasm() must be awaited first!");
12055 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
12056 return nativeResponseValue;
12058 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
12060 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
12061 if(!isWasmInitialized) {
12062 throw new Error("initializeWasm() must be awaited first!");
12064 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
12065 return nativeResponseValue;
12067 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_ok(struct LDKSchnorrSignature o);
12069 export function CResult_SchnorrSignatureNoneZ_ok(o: number): bigint {
12070 if(!isWasmInitialized) {
12071 throw new Error("initializeWasm() must be awaited first!");
12073 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_ok(o);
12074 return nativeResponseValue;
12076 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_err(void);
12078 export function CResult_SchnorrSignatureNoneZ_err(): bigint {
12079 if(!isWasmInitialized) {
12080 throw new Error("initializeWasm() must be awaited first!");
12082 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_err();
12083 return nativeResponseValue;
12085 // bool CResult_SchnorrSignatureNoneZ_is_ok(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR o);
12087 export function CResult_SchnorrSignatureNoneZ_is_ok(o: bigint): boolean {
12088 if(!isWasmInitialized) {
12089 throw new Error("initializeWasm() must be awaited first!");
12091 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_is_ok(o);
12092 return nativeResponseValue;
12094 // void CResult_SchnorrSignatureNoneZ_free(struct LDKCResult_SchnorrSignatureNoneZ _res);
12096 export function CResult_SchnorrSignatureNoneZ_free(_res: bigint): void {
12097 if(!isWasmInitialized) {
12098 throw new Error("initializeWasm() must be awaited first!");
12100 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_free(_res);
12101 // debug statements here
12103 // uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg);
12105 export function CResult_SchnorrSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12106 if(!isWasmInitialized) {
12107 throw new Error("initializeWasm() must be awaited first!");
12109 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone_ptr(arg);
12110 return nativeResponseValue;
12112 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_clone(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR orig);
12114 export function CResult_SchnorrSignatureNoneZ_clone(orig: bigint): bigint {
12115 if(!isWasmInitialized) {
12116 throw new Error("initializeWasm() must be awaited first!");
12118 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone(orig);
12119 return nativeResponseValue;
12121 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
12123 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
12124 if(!isWasmInitialized) {
12125 throw new Error("initializeWasm() must be awaited first!");
12127 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
12128 return nativeResponseValue;
12130 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
12132 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
12133 if(!isWasmInitialized) {
12134 throw new Error("initializeWasm() must be awaited first!");
12136 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
12137 return nativeResponseValue;
12139 // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
12141 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
12142 if(!isWasmInitialized) {
12143 throw new Error("initializeWasm() must be awaited first!");
12145 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
12146 return nativeResponseValue;
12148 // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
12150 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
12151 if(!isWasmInitialized) {
12152 throw new Error("initializeWasm() must be awaited first!");
12154 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
12155 // debug statements here
12157 // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
12159 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12160 if(!isWasmInitialized) {
12161 throw new Error("initializeWasm() must be awaited first!");
12163 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
12164 return nativeResponseValue;
12166 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
12168 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
12169 if(!isWasmInitialized) {
12170 throw new Error("initializeWasm() must be awaited first!");
12172 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
12173 return nativeResponseValue;
12175 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_ok(struct LDKCVec_u8Z o);
12177 export function CResult_CVec_u8ZNoneZ_ok(o: number): bigint {
12178 if(!isWasmInitialized) {
12179 throw new Error("initializeWasm() must be awaited first!");
12181 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_ok(o);
12182 return nativeResponseValue;
12184 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_err(void);
12186 export function CResult_CVec_u8ZNoneZ_err(): bigint {
12187 if(!isWasmInitialized) {
12188 throw new Error("initializeWasm() must be awaited first!");
12190 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_err();
12191 return nativeResponseValue;
12193 // bool CResult_CVec_u8ZNoneZ_is_ok(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR o);
12195 export function CResult_CVec_u8ZNoneZ_is_ok(o: bigint): boolean {
12196 if(!isWasmInitialized) {
12197 throw new Error("initializeWasm() must be awaited first!");
12199 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_is_ok(o);
12200 return nativeResponseValue;
12202 // void CResult_CVec_u8ZNoneZ_free(struct LDKCResult_CVec_u8ZNoneZ _res);
12204 export function CResult_CVec_u8ZNoneZ_free(_res: bigint): void {
12205 if(!isWasmInitialized) {
12206 throw new Error("initializeWasm() must be awaited first!");
12208 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_free(_res);
12209 // debug statements here
12211 // uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg);
12213 export function CResult_CVec_u8ZNoneZ_clone_ptr(arg: bigint): bigint {
12214 if(!isWasmInitialized) {
12215 throw new Error("initializeWasm() must be awaited first!");
12217 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone_ptr(arg);
12218 return nativeResponseValue;
12220 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_clone(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR orig);
12222 export function CResult_CVec_u8ZNoneZ_clone(orig: bigint): bigint {
12223 if(!isWasmInitialized) {
12224 throw new Error("initializeWasm() must be awaited first!");
12226 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone(orig);
12227 return nativeResponseValue;
12229 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
12231 export function CResult_ShutdownScriptNoneZ_ok(o: bigint): bigint {
12232 if(!isWasmInitialized) {
12233 throw new Error("initializeWasm() must be awaited first!");
12235 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_ok(o);
12236 return nativeResponseValue;
12238 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
12240 export function CResult_ShutdownScriptNoneZ_err(): bigint {
12241 if(!isWasmInitialized) {
12242 throw new Error("initializeWasm() must be awaited first!");
12244 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_err();
12245 return nativeResponseValue;
12247 // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
12249 export function CResult_ShutdownScriptNoneZ_is_ok(o: bigint): boolean {
12250 if(!isWasmInitialized) {
12251 throw new Error("initializeWasm() must be awaited first!");
12253 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_is_ok(o);
12254 return nativeResponseValue;
12256 // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
12258 export function CResult_ShutdownScriptNoneZ_free(_res: bigint): void {
12259 if(!isWasmInitialized) {
12260 throw new Error("initializeWasm() must be awaited first!");
12262 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_free(_res);
12263 // debug statements here
12265 // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
12267 export function CResult_ShutdownScriptNoneZ_clone_ptr(arg: bigint): bigint {
12268 if(!isWasmInitialized) {
12269 throw new Error("initializeWasm() must be awaited first!");
12271 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone_ptr(arg);
12272 return nativeResponseValue;
12274 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
12276 export function CResult_ShutdownScriptNoneZ_clone(orig: bigint): bigint {
12277 if(!isWasmInitialized) {
12278 throw new Error("initializeWasm() must be awaited first!");
12280 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone(orig);
12281 return nativeResponseValue;
12283 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
12285 export function COption_u16Z_some(o: number): bigint {
12286 if(!isWasmInitialized) {
12287 throw new Error("initializeWasm() must be awaited first!");
12289 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
12290 return nativeResponseValue;
12292 // struct LDKCOption_u16Z COption_u16Z_none(void);
12294 export function COption_u16Z_none(): bigint {
12295 if(!isWasmInitialized) {
12296 throw new Error("initializeWasm() must be awaited first!");
12298 const nativeResponseValue = wasm.TS_COption_u16Z_none();
12299 return nativeResponseValue;
12301 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
12303 export function COption_u16Z_free(_res: bigint): void {
12304 if(!isWasmInitialized) {
12305 throw new Error("initializeWasm() must be awaited first!");
12307 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
12308 // debug statements here
12310 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
12312 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
12313 if(!isWasmInitialized) {
12314 throw new Error("initializeWasm() must be awaited first!");
12316 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
12317 return nativeResponseValue;
12319 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
12321 export function COption_u16Z_clone(orig: bigint): bigint {
12322 if(!isWasmInitialized) {
12323 throw new Error("initializeWasm() must be awaited first!");
12325 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
12326 return nativeResponseValue;
12328 // struct LDKCOption_boolZ COption_boolZ_some(bool o);
12330 export function COption_boolZ_some(o: boolean): bigint {
12331 if(!isWasmInitialized) {
12332 throw new Error("initializeWasm() must be awaited first!");
12334 const nativeResponseValue = wasm.TS_COption_boolZ_some(o);
12335 return nativeResponseValue;
12337 // struct LDKCOption_boolZ COption_boolZ_none(void);
12339 export function COption_boolZ_none(): bigint {
12340 if(!isWasmInitialized) {
12341 throw new Error("initializeWasm() must be awaited first!");
12343 const nativeResponseValue = wasm.TS_COption_boolZ_none();
12344 return nativeResponseValue;
12346 // void COption_boolZ_free(struct LDKCOption_boolZ _res);
12348 export function COption_boolZ_free(_res: bigint): void {
12349 if(!isWasmInitialized) {
12350 throw new Error("initializeWasm() must be awaited first!");
12352 const nativeResponseValue = wasm.TS_COption_boolZ_free(_res);
12353 // debug statements here
12355 // uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg);
12357 export function COption_boolZ_clone_ptr(arg: bigint): bigint {
12358 if(!isWasmInitialized) {
12359 throw new Error("initializeWasm() must be awaited first!");
12361 const nativeResponseValue = wasm.TS_COption_boolZ_clone_ptr(arg);
12362 return nativeResponseValue;
12364 // struct LDKCOption_boolZ COption_boolZ_clone(const struct LDKCOption_boolZ *NONNULL_PTR orig);
12366 export function COption_boolZ_clone(orig: bigint): bigint {
12367 if(!isWasmInitialized) {
12368 throw new Error("initializeWasm() must be awaited first!");
12370 const nativeResponseValue = wasm.TS_COption_boolZ_clone(orig);
12371 return nativeResponseValue;
12373 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
12375 export function CVec_CVec_u8ZZ_free(_res: number): void {
12376 if(!isWasmInitialized) {
12377 throw new Error("initializeWasm() must be awaited first!");
12379 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
12380 // debug statements here
12382 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
12384 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
12385 if(!isWasmInitialized) {
12386 throw new Error("initializeWasm() must be awaited first!");
12388 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
12389 return nativeResponseValue;
12391 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
12393 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
12394 if(!isWasmInitialized) {
12395 throw new Error("initializeWasm() must be awaited first!");
12397 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
12398 return nativeResponseValue;
12400 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
12402 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
12403 if(!isWasmInitialized) {
12404 throw new Error("initializeWasm() must be awaited first!");
12406 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
12407 return nativeResponseValue;
12409 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
12411 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
12412 if(!isWasmInitialized) {
12413 throw new Error("initializeWasm() must be awaited first!");
12415 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
12416 // debug statements here
12418 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
12420 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
12421 if(!isWasmInitialized) {
12422 throw new Error("initializeWasm() must be awaited first!");
12424 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
12425 return nativeResponseValue;
12427 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
12429 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
12430 if(!isWasmInitialized) {
12431 throw new Error("initializeWasm() must be awaited first!");
12433 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
12434 return nativeResponseValue;
12436 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
12438 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
12439 if(!isWasmInitialized) {
12440 throw new Error("initializeWasm() must be awaited first!");
12442 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
12443 return nativeResponseValue;
12445 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
12447 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
12448 if(!isWasmInitialized) {
12449 throw new Error("initializeWasm() must be awaited first!");
12451 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
12452 return nativeResponseValue;
12454 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
12456 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
12457 if(!isWasmInitialized) {
12458 throw new Error("initializeWasm() must be awaited first!");
12460 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
12461 return nativeResponseValue;
12463 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
12465 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
12466 if(!isWasmInitialized) {
12467 throw new Error("initializeWasm() must be awaited first!");
12469 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
12470 // debug statements here
12472 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
12474 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12475 if(!isWasmInitialized) {
12476 throw new Error("initializeWasm() must be awaited first!");
12478 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
12479 return nativeResponseValue;
12481 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
12483 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
12484 if(!isWasmInitialized) {
12485 throw new Error("initializeWasm() must be awaited first!");
12487 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
12488 return nativeResponseValue;
12490 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
12492 export function CResult_TransactionNoneZ_ok(o: number): bigint {
12493 if(!isWasmInitialized) {
12494 throw new Error("initializeWasm() must be awaited first!");
12496 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
12497 return nativeResponseValue;
12499 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
12501 export function CResult_TransactionNoneZ_err(): bigint {
12502 if(!isWasmInitialized) {
12503 throw new Error("initializeWasm() must be awaited first!");
12505 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
12506 return nativeResponseValue;
12508 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
12510 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
12511 if(!isWasmInitialized) {
12512 throw new Error("initializeWasm() must be awaited first!");
12514 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
12515 return nativeResponseValue;
12517 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
12519 export function CResult_TransactionNoneZ_free(_res: bigint): void {
12520 if(!isWasmInitialized) {
12521 throw new Error("initializeWasm() must be awaited first!");
12523 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
12524 // debug statements here
12526 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
12528 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
12529 if(!isWasmInitialized) {
12530 throw new Error("initializeWasm() must be awaited first!");
12532 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
12533 return nativeResponseValue;
12535 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
12537 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
12538 if(!isWasmInitialized) {
12539 throw new Error("initializeWasm() must be awaited first!");
12541 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
12542 return nativeResponseValue;
12544 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
12546 export function CVec_ChannelDetailsZ_free(_res: number): void {
12547 if(!isWasmInitialized) {
12548 throw new Error("initializeWasm() must be awaited first!");
12550 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
12551 // debug statements here
12553 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
12555 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
12556 if(!isWasmInitialized) {
12557 throw new Error("initializeWasm() must be awaited first!");
12559 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
12560 return nativeResponseValue;
12562 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
12564 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
12565 if(!isWasmInitialized) {
12566 throw new Error("initializeWasm() must be awaited first!");
12568 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
12569 return nativeResponseValue;
12571 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
12573 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
12574 if(!isWasmInitialized) {
12575 throw new Error("initializeWasm() must be awaited first!");
12577 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
12578 return nativeResponseValue;
12580 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
12582 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
12583 if(!isWasmInitialized) {
12584 throw new Error("initializeWasm() must be awaited first!");
12586 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
12587 // debug statements here
12589 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
12591 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
12592 if(!isWasmInitialized) {
12593 throw new Error("initializeWasm() must be awaited first!");
12595 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
12596 return nativeResponseValue;
12598 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
12600 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
12601 if(!isWasmInitialized) {
12602 throw new Error("initializeWasm() must be awaited first!");
12604 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
12605 return nativeResponseValue;
12607 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
12609 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
12610 if(!isWasmInitialized) {
12611 throw new Error("initializeWasm() must be awaited first!");
12613 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
12614 return nativeResponseValue;
12616 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
12618 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
12619 if(!isWasmInitialized) {
12620 throw new Error("initializeWasm() must be awaited first!");
12622 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
12623 return nativeResponseValue;
12625 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
12627 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
12628 if(!isWasmInitialized) {
12629 throw new Error("initializeWasm() must be awaited first!");
12631 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
12632 return nativeResponseValue;
12634 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
12636 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
12637 if(!isWasmInitialized) {
12638 throw new Error("initializeWasm() must be awaited first!");
12640 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
12641 // debug statements here
12643 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
12645 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12646 if(!isWasmInitialized) {
12647 throw new Error("initializeWasm() must be awaited first!");
12649 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
12650 return nativeResponseValue;
12652 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
12654 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
12655 if(!isWasmInitialized) {
12656 throw new Error("initializeWasm() must be awaited first!");
12658 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
12659 return nativeResponseValue;
12661 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
12663 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
12664 if(!isWasmInitialized) {
12665 throw new Error("initializeWasm() must be awaited first!");
12667 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
12668 return nativeResponseValue;
12670 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
12672 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
12673 if(!isWasmInitialized) {
12674 throw new Error("initializeWasm() must be awaited first!");
12676 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
12677 return nativeResponseValue;
12679 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
12681 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
12682 if(!isWasmInitialized) {
12683 throw new Error("initializeWasm() must be awaited first!");
12685 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
12686 return nativeResponseValue;
12688 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
12690 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
12691 if(!isWasmInitialized) {
12692 throw new Error("initializeWasm() must be awaited first!");
12694 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
12695 // debug statements here
12697 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
12699 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12700 if(!isWasmInitialized) {
12701 throw new Error("initializeWasm() must be awaited first!");
12703 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
12704 return nativeResponseValue;
12706 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
12708 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
12709 if(!isWasmInitialized) {
12710 throw new Error("initializeWasm() must be awaited first!");
12712 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
12713 return nativeResponseValue;
12715 // void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
12717 export function CVec_BlindedHopZ_free(_res: number): void {
12718 if(!isWasmInitialized) {
12719 throw new Error("initializeWasm() must be awaited first!");
12721 const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
12722 // debug statements here
12724 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
12726 export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
12727 if(!isWasmInitialized) {
12728 throw new Error("initializeWasm() must be awaited first!");
12730 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
12731 return nativeResponseValue;
12733 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
12735 export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
12736 if(!isWasmInitialized) {
12737 throw new Error("initializeWasm() must be awaited first!");
12739 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
12740 return nativeResponseValue;
12742 // bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
12744 export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
12745 if(!isWasmInitialized) {
12746 throw new Error("initializeWasm() must be awaited first!");
12748 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
12749 return nativeResponseValue;
12751 // void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
12753 export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
12754 if(!isWasmInitialized) {
12755 throw new Error("initializeWasm() must be awaited first!");
12757 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
12758 // debug statements here
12760 // uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
12762 export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12763 if(!isWasmInitialized) {
12764 throw new Error("initializeWasm() must be awaited first!");
12766 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
12767 return nativeResponseValue;
12769 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
12771 export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
12772 if(!isWasmInitialized) {
12773 throw new Error("initializeWasm() must be awaited first!");
12775 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
12776 return nativeResponseValue;
12778 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
12780 export function CVec_RouteHopZ_free(_res: number): void {
12781 if(!isWasmInitialized) {
12782 throw new Error("initializeWasm() must be awaited first!");
12784 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
12785 // debug statements here
12787 // void CVec_PathZ_free(struct LDKCVec_PathZ _res);
12789 export function CVec_PathZ_free(_res: number): void {
12790 if(!isWasmInitialized) {
12791 throw new Error("initializeWasm() must be awaited first!");
12793 const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
12794 // debug statements here
12796 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
12798 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
12799 if(!isWasmInitialized) {
12800 throw new Error("initializeWasm() must be awaited first!");
12802 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
12803 return nativeResponseValue;
12805 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
12807 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
12808 if(!isWasmInitialized) {
12809 throw new Error("initializeWasm() must be awaited first!");
12811 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
12812 return nativeResponseValue;
12814 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
12816 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
12817 if(!isWasmInitialized) {
12818 throw new Error("initializeWasm() must be awaited first!");
12820 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
12821 return nativeResponseValue;
12823 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
12825 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
12826 if(!isWasmInitialized) {
12827 throw new Error("initializeWasm() must be awaited first!");
12829 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
12830 // debug statements here
12832 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
12834 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12835 if(!isWasmInitialized) {
12836 throw new Error("initializeWasm() must be awaited first!");
12838 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
12839 return nativeResponseValue;
12841 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
12843 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
12844 if(!isWasmInitialized) {
12845 throw new Error("initializeWasm() must be awaited first!");
12847 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
12848 return nativeResponseValue;
12850 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
12852 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
12853 if(!isWasmInitialized) {
12854 throw new Error("initializeWasm() must be awaited first!");
12856 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
12857 return nativeResponseValue;
12859 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
12861 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
12862 if(!isWasmInitialized) {
12863 throw new Error("initializeWasm() must be awaited first!");
12865 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
12866 return nativeResponseValue;
12868 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
12870 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
12871 if(!isWasmInitialized) {
12872 throw new Error("initializeWasm() must be awaited first!");
12874 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
12875 return nativeResponseValue;
12877 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
12879 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
12880 if(!isWasmInitialized) {
12881 throw new Error("initializeWasm() must be awaited first!");
12883 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
12884 // debug statements here
12886 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
12888 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12889 if(!isWasmInitialized) {
12890 throw new Error("initializeWasm() must be awaited first!");
12892 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
12893 return nativeResponseValue;
12895 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
12897 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
12898 if(!isWasmInitialized) {
12899 throw new Error("initializeWasm() must be awaited first!");
12901 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
12902 return nativeResponseValue;
12904 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
12906 export function CVec_u64Z_free(_res: number): void {
12907 if(!isWasmInitialized) {
12908 throw new Error("initializeWasm() must be awaited first!");
12910 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
12911 // debug statements here
12913 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
12915 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
12916 if(!isWasmInitialized) {
12917 throw new Error("initializeWasm() must be awaited first!");
12919 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
12920 return nativeResponseValue;
12922 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
12924 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
12925 if(!isWasmInitialized) {
12926 throw new Error("initializeWasm() must be awaited first!");
12928 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
12929 return nativeResponseValue;
12931 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
12933 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
12934 if(!isWasmInitialized) {
12935 throw new Error("initializeWasm() must be awaited first!");
12937 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
12938 return nativeResponseValue;
12940 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
12942 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
12943 if(!isWasmInitialized) {
12944 throw new Error("initializeWasm() must be awaited first!");
12946 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
12947 // debug statements here
12949 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
12951 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12952 if(!isWasmInitialized) {
12953 throw new Error("initializeWasm() must be awaited first!");
12955 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
12956 return nativeResponseValue;
12958 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
12960 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
12961 if(!isWasmInitialized) {
12962 throw new Error("initializeWasm() must be awaited first!");
12964 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
12965 return nativeResponseValue;
12967 // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
12969 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
12970 if(!isWasmInitialized) {
12971 throw new Error("initializeWasm() must be awaited first!");
12973 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
12974 return nativeResponseValue;
12976 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
12978 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
12979 if(!isWasmInitialized) {
12980 throw new Error("initializeWasm() must be awaited first!");
12982 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
12983 return nativeResponseValue;
12985 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
12987 export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
12988 if(!isWasmInitialized) {
12989 throw new Error("initializeWasm() must be awaited first!");
12991 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
12992 return nativeResponseValue;
12994 // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
12996 export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
12997 if(!isWasmInitialized) {
12998 throw new Error("initializeWasm() must be awaited first!");
13000 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
13001 // debug statements here
13003 // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
13005 export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
13006 if(!isWasmInitialized) {
13007 throw new Error("initializeWasm() must be awaited first!");
13009 const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
13010 // debug statements here
13012 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
13014 export function CVec_RouteHintZ_free(_res: number): void {
13015 if(!isWasmInitialized) {
13016 throw new Error("initializeWasm() must be awaited first!");
13018 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
13019 // debug statements here
13021 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
13023 export function CVec_RouteHintHopZ_free(_res: number): void {
13024 if(!isWasmInitialized) {
13025 throw new Error("initializeWasm() must be awaited first!");
13027 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
13028 // debug statements here
13030 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
13032 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
13033 if(!isWasmInitialized) {
13034 throw new Error("initializeWasm() must be awaited first!");
13036 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
13037 return nativeResponseValue;
13039 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
13041 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
13042 if(!isWasmInitialized) {
13043 throw new Error("initializeWasm() must be awaited first!");
13045 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
13046 return nativeResponseValue;
13048 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
13050 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
13051 if(!isWasmInitialized) {
13052 throw new Error("initializeWasm() must be awaited first!");
13054 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
13055 return nativeResponseValue;
13057 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
13059 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
13060 if(!isWasmInitialized) {
13061 throw new Error("initializeWasm() must be awaited first!");
13063 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
13064 // debug statements here
13066 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
13068 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13069 if(!isWasmInitialized) {
13070 throw new Error("initializeWasm() must be awaited first!");
13072 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
13073 return nativeResponseValue;
13075 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
13077 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
13078 if(!isWasmInitialized) {
13079 throw new Error("initializeWasm() must be awaited first!");
13081 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
13082 return nativeResponseValue;
13084 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
13086 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
13087 if(!isWasmInitialized) {
13088 throw new Error("initializeWasm() must be awaited first!");
13090 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
13091 return nativeResponseValue;
13093 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
13095 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
13096 if(!isWasmInitialized) {
13097 throw new Error("initializeWasm() must be awaited first!");
13099 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
13100 return nativeResponseValue;
13102 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
13104 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
13105 if(!isWasmInitialized) {
13106 throw new Error("initializeWasm() must be awaited first!");
13108 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
13109 return nativeResponseValue;
13111 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
13113 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
13114 if(!isWasmInitialized) {
13115 throw new Error("initializeWasm() must be awaited first!");
13117 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
13118 // debug statements here
13120 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
13122 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13123 if(!isWasmInitialized) {
13124 throw new Error("initializeWasm() must be awaited first!");
13126 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
13127 return nativeResponseValue;
13129 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
13131 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
13132 if(!isWasmInitialized) {
13133 throw new Error("initializeWasm() must be awaited first!");
13135 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
13136 return nativeResponseValue;
13138 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
13140 export function CVec_PublicKeyZ_free(_res: number): void {
13141 if(!isWasmInitialized) {
13142 throw new Error("initializeWasm() must be awaited first!");
13144 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
13145 // debug statements here
13147 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
13149 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
13150 if(!isWasmInitialized) {
13151 throw new Error("initializeWasm() must be awaited first!");
13153 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
13154 return nativeResponseValue;
13156 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
13158 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
13159 if(!isWasmInitialized) {
13160 throw new Error("initializeWasm() must be awaited first!");
13162 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
13163 return nativeResponseValue;
13165 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
13167 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
13168 if(!isWasmInitialized) {
13169 throw new Error("initializeWasm() must be awaited first!");
13171 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
13172 return nativeResponseValue;
13174 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
13176 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
13177 if(!isWasmInitialized) {
13178 throw new Error("initializeWasm() must be awaited first!");
13180 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
13181 // debug statements here
13183 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
13185 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13186 if(!isWasmInitialized) {
13187 throw new Error("initializeWasm() must be awaited first!");
13189 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
13190 return nativeResponseValue;
13192 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
13194 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
13195 if(!isWasmInitialized) {
13196 throw new Error("initializeWasm() must be awaited first!");
13198 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
13199 return nativeResponseValue;
13201 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
13203 export function CVec_NodeIdZ_free(_res: number): void {
13204 if(!isWasmInitialized) {
13205 throw new Error("initializeWasm() must be awaited first!");
13207 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
13208 // debug statements here
13210 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
13212 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
13213 if(!isWasmInitialized) {
13214 throw new Error("initializeWasm() must be awaited first!");
13216 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
13217 return nativeResponseValue;
13219 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
13221 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
13222 if(!isWasmInitialized) {
13223 throw new Error("initializeWasm() must be awaited first!");
13225 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
13226 return nativeResponseValue;
13228 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
13230 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
13231 if(!isWasmInitialized) {
13232 throw new Error("initializeWasm() must be awaited first!");
13234 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
13235 return nativeResponseValue;
13237 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
13239 export function C2Tuple_u64u64Z_free(_res: bigint): void {
13240 if(!isWasmInitialized) {
13241 throw new Error("initializeWasm() must be awaited first!");
13243 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
13244 // debug statements here
13246 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
13248 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
13249 if(!isWasmInitialized) {
13250 throw new Error("initializeWasm() must be awaited first!");
13252 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
13253 return nativeResponseValue;
13255 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
13257 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
13258 if(!isWasmInitialized) {
13259 throw new Error("initializeWasm() must be awaited first!");
13261 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
13262 return nativeResponseValue;
13264 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
13266 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
13267 if(!isWasmInitialized) {
13268 throw new Error("initializeWasm() must be awaited first!");
13270 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
13271 // debug statements here
13273 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
13275 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
13276 if(!isWasmInitialized) {
13277 throw new Error("initializeWasm() must be awaited first!");
13279 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
13280 return nativeResponseValue;
13282 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
13284 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
13285 if(!isWasmInitialized) {
13286 throw new Error("initializeWasm() must be awaited first!");
13288 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
13289 return nativeResponseValue;
13291 // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
13293 export function C2Tuple_Z_new(a: number, b: number): bigint {
13294 if(!isWasmInitialized) {
13295 throw new Error("initializeWasm() must be awaited first!");
13297 const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
13298 return nativeResponseValue;
13300 // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
13302 export function C2Tuple_Z_free(_res: bigint): void {
13303 if(!isWasmInitialized) {
13304 throw new Error("initializeWasm() must be awaited first!");
13306 const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
13307 // debug statements here
13309 // struct LDKC2Tuple__u1632_u1632Z C2Tuple__u1632_u1632Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
13311 export function C2Tuple__u1632_u1632Z_new(a: number, b: number): bigint {
13312 if(!isWasmInitialized) {
13313 throw new Error("initializeWasm() must be awaited first!");
13315 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_new(a, b);
13316 return nativeResponseValue;
13318 // void C2Tuple__u1632_u1632Z_free(struct LDKC2Tuple__u1632_u1632Z _res);
13320 export function C2Tuple__u1632_u1632Z_free(_res: bigint): void {
13321 if(!isWasmInitialized) {
13322 throw new Error("initializeWasm() must be awaited first!");
13324 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_free(_res);
13325 // debug statements here
13327 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(struct LDKC2Tuple__u1632_u1632Z o);
13329 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o: bigint): bigint {
13330 if(!isWasmInitialized) {
13331 throw new Error("initializeWasm() must be awaited first!");
13333 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o);
13334 return nativeResponseValue;
13336 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(void);
13338 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(): bigint {
13339 if(!isWasmInitialized) {
13340 throw new Error("initializeWasm() must be awaited first!");
13342 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none();
13343 return nativeResponseValue;
13345 // void COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ _res);
13347 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res: bigint): void {
13348 if(!isWasmInitialized) {
13349 throw new Error("initializeWasm() must be awaited first!");
13351 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res);
13352 // debug statements here
13354 // struct LDKCOption_f64Z COption_f64Z_some(double o);
13356 export function COption_f64Z_some(o: number): bigint {
13357 if(!isWasmInitialized) {
13358 throw new Error("initializeWasm() must be awaited first!");
13360 const nativeResponseValue = wasm.TS_COption_f64Z_some(o);
13361 return nativeResponseValue;
13363 // struct LDKCOption_f64Z COption_f64Z_none(void);
13365 export function COption_f64Z_none(): bigint {
13366 if(!isWasmInitialized) {
13367 throw new Error("initializeWasm() must be awaited first!");
13369 const nativeResponseValue = wasm.TS_COption_f64Z_none();
13370 return nativeResponseValue;
13372 // void COption_f64Z_free(struct LDKCOption_f64Z _res);
13374 export function COption_f64Z_free(_res: bigint): void {
13375 if(!isWasmInitialized) {
13376 throw new Error("initializeWasm() must be awaited first!");
13378 const nativeResponseValue = wasm.TS_COption_f64Z_free(_res);
13379 // debug statements here
13381 // uint64_t COption_f64Z_clone_ptr(LDKCOption_f64Z *NONNULL_PTR arg);
13383 export function COption_f64Z_clone_ptr(arg: bigint): bigint {
13384 if(!isWasmInitialized) {
13385 throw new Error("initializeWasm() must be awaited first!");
13387 const nativeResponseValue = wasm.TS_COption_f64Z_clone_ptr(arg);
13388 return nativeResponseValue;
13390 // struct LDKCOption_f64Z COption_f64Z_clone(const struct LDKCOption_f64Z *NONNULL_PTR orig);
13392 export function COption_f64Z_clone(orig: bigint): bigint {
13393 if(!isWasmInitialized) {
13394 throw new Error("initializeWasm() must be awaited first!");
13396 const nativeResponseValue = wasm.TS_COption_f64Z_clone(orig);
13397 return nativeResponseValue;
13399 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
13401 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
13402 if(!isWasmInitialized) {
13403 throw new Error("initializeWasm() must be awaited first!");
13405 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
13406 return nativeResponseValue;
13408 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
13410 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
13411 if(!isWasmInitialized) {
13412 throw new Error("initializeWasm() must be awaited first!");
13414 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
13415 return nativeResponseValue;
13417 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
13419 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
13420 if(!isWasmInitialized) {
13421 throw new Error("initializeWasm() must be awaited first!");
13423 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
13424 return nativeResponseValue;
13426 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
13428 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
13429 if(!isWasmInitialized) {
13430 throw new Error("initializeWasm() must be awaited first!");
13432 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
13433 // debug statements here
13435 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
13437 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
13438 if(!isWasmInitialized) {
13439 throw new Error("initializeWasm() must be awaited first!");
13441 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
13442 return nativeResponseValue;
13444 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
13446 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
13447 if(!isWasmInitialized) {
13448 throw new Error("initializeWasm() must be awaited first!");
13450 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
13451 return nativeResponseValue;
13453 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
13455 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
13456 if(!isWasmInitialized) {
13457 throw new Error("initializeWasm() must be awaited first!");
13459 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
13460 return nativeResponseValue;
13462 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
13464 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
13465 if(!isWasmInitialized) {
13466 throw new Error("initializeWasm() must be awaited first!");
13468 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
13469 // debug statements here
13471 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
13473 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
13474 if(!isWasmInitialized) {
13475 throw new Error("initializeWasm() must be awaited first!");
13477 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
13478 // debug statements here
13480 // uint64_t C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR arg);
13482 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
13483 if(!isWasmInitialized) {
13484 throw new Error("initializeWasm() must be awaited first!");
13486 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg);
13487 return nativeResponseValue;
13489 // struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR orig);
13491 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
13492 if(!isWasmInitialized) {
13493 throw new Error("initializeWasm() must be awaited first!");
13495 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig);
13496 return nativeResponseValue;
13498 // struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(struct LDKThirtyTwoBytes a, struct LDKCOption_ThirtyTwoBytesZ b);
13500 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a: number, b: bigint): bigint {
13501 if(!isWasmInitialized) {
13502 throw new Error("initializeWasm() must be awaited first!");
13504 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a, b);
13505 return nativeResponseValue;
13507 // void C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ _res);
13509 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res: bigint): void {
13510 if(!isWasmInitialized) {
13511 throw new Error("initializeWasm() must be awaited first!");
13513 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res);
13514 // debug statements here
13516 // void CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ _res);
13518 export function CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res: number): void {
13519 if(!isWasmInitialized) {
13520 throw new Error("initializeWasm() must be awaited first!");
13522 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res);
13523 // debug statements here
13525 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_ok(enum LDKChannelMonitorUpdateStatus o);
13527 export function CResult_ChannelMonitorUpdateStatusNoneZ_ok(o: ChannelMonitorUpdateStatus): bigint {
13528 if(!isWasmInitialized) {
13529 throw new Error("initializeWasm() must be awaited first!");
13531 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok(o);
13532 return nativeResponseValue;
13534 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_err(void);
13536 export function CResult_ChannelMonitorUpdateStatusNoneZ_err(): bigint {
13537 if(!isWasmInitialized) {
13538 throw new Error("initializeWasm() must be awaited first!");
13540 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_err();
13541 return nativeResponseValue;
13543 // bool CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR o);
13545 export function CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o: bigint): boolean {
13546 if(!isWasmInitialized) {
13547 throw new Error("initializeWasm() must be awaited first!");
13549 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o);
13550 return nativeResponseValue;
13552 // void CResult_ChannelMonitorUpdateStatusNoneZ_free(struct LDKCResult_ChannelMonitorUpdateStatusNoneZ _res);
13554 export function CResult_ChannelMonitorUpdateStatusNoneZ_free(_res: bigint): void {
13555 if(!isWasmInitialized) {
13556 throw new Error("initializeWasm() must be awaited first!");
13558 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_free(_res);
13559 // debug statements here
13561 // uint64_t CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR arg);
13563 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg: bigint): bigint {
13564 if(!isWasmInitialized) {
13565 throw new Error("initializeWasm() must be awaited first!");
13567 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg);
13568 return nativeResponseValue;
13570 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_clone(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR orig);
13572 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig: bigint): bigint {
13573 if(!isWasmInitialized) {
13574 throw new Error("initializeWasm() must be awaited first!");
13576 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig);
13577 return nativeResponseValue;
13579 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
13581 export function CVec_MonitorEventZ_free(_res: number): void {
13582 if(!isWasmInitialized) {
13583 throw new Error("initializeWasm() must be awaited first!");
13585 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
13586 // debug statements here
13588 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
13590 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
13591 if(!isWasmInitialized) {
13592 throw new Error("initializeWasm() must be awaited first!");
13594 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
13595 return nativeResponseValue;
13597 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
13599 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
13600 if(!isWasmInitialized) {
13601 throw new Error("initializeWasm() must be awaited first!");
13603 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
13604 return nativeResponseValue;
13606 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
13608 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
13609 if(!isWasmInitialized) {
13610 throw new Error("initializeWasm() must be awaited first!");
13612 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
13613 return nativeResponseValue;
13615 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
13617 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
13618 if(!isWasmInitialized) {
13619 throw new Error("initializeWasm() must be awaited first!");
13621 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
13622 // debug statements here
13624 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
13626 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
13627 if(!isWasmInitialized) {
13628 throw new Error("initializeWasm() must be awaited first!");
13630 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
13631 // debug statements here
13633 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
13635 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13636 if(!isWasmInitialized) {
13637 throw new Error("initializeWasm() must be awaited first!");
13639 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
13640 return nativeResponseValue;
13642 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13644 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
13645 if(!isWasmInitialized) {
13646 throw new Error("initializeWasm() must be awaited first!");
13648 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
13649 return nativeResponseValue;
13651 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
13653 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13654 if(!isWasmInitialized) {
13655 throw new Error("initializeWasm() must be awaited first!");
13657 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
13658 return nativeResponseValue;
13660 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
13662 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
13663 if(!isWasmInitialized) {
13664 throw new Error("initializeWasm() must be awaited first!");
13666 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
13667 // debug statements here
13669 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
13671 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13672 if(!isWasmInitialized) {
13673 throw new Error("initializeWasm() must be awaited first!");
13675 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
13676 return nativeResponseValue;
13678 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
13680 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13681 if(!isWasmInitialized) {
13682 throw new Error("initializeWasm() must be awaited first!");
13684 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
13685 return nativeResponseValue;
13687 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
13689 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13690 if(!isWasmInitialized) {
13691 throw new Error("initializeWasm() must be awaited first!");
13693 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
13694 return nativeResponseValue;
13696 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13698 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
13699 if(!isWasmInitialized) {
13700 throw new Error("initializeWasm() must be awaited first!");
13702 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
13703 return nativeResponseValue;
13705 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
13707 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13708 if(!isWasmInitialized) {
13709 throw new Error("initializeWasm() must be awaited first!");
13711 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
13712 return nativeResponseValue;
13714 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
13716 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
13717 if(!isWasmInitialized) {
13718 throw new Error("initializeWasm() must be awaited first!");
13720 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
13721 // debug statements here
13723 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
13725 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13726 if(!isWasmInitialized) {
13727 throw new Error("initializeWasm() must be awaited first!");
13729 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
13730 return nativeResponseValue;
13732 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
13734 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13735 if(!isWasmInitialized) {
13736 throw new Error("initializeWasm() must be awaited first!");
13738 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
13739 return nativeResponseValue;
13741 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
13743 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13744 if(!isWasmInitialized) {
13745 throw new Error("initializeWasm() must be awaited first!");
13747 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
13748 return nativeResponseValue;
13750 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13752 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
13753 if(!isWasmInitialized) {
13754 throw new Error("initializeWasm() must be awaited first!");
13756 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
13757 return nativeResponseValue;
13759 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
13761 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13762 if(!isWasmInitialized) {
13763 throw new Error("initializeWasm() must be awaited first!");
13765 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
13766 return nativeResponseValue;
13768 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
13770 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
13771 if(!isWasmInitialized) {
13772 throw new Error("initializeWasm() must be awaited first!");
13774 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
13775 // debug statements here
13777 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
13779 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13780 if(!isWasmInitialized) {
13781 throw new Error("initializeWasm() must be awaited first!");
13783 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
13784 return nativeResponseValue;
13786 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
13788 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13789 if(!isWasmInitialized) {
13790 throw new Error("initializeWasm() must be awaited first!");
13792 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
13793 return nativeResponseValue;
13795 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt11InvoiceFeatures o);
13797 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13798 if(!isWasmInitialized) {
13799 throw new Error("initializeWasm() must be awaited first!");
13801 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o);
13802 return nativeResponseValue;
13804 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13806 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
13807 if(!isWasmInitialized) {
13808 throw new Error("initializeWasm() must be awaited first!");
13810 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e);
13811 return nativeResponseValue;
13813 // bool CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
13815 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13816 if(!isWasmInitialized) {
13817 throw new Error("initializeWasm() must be awaited first!");
13819 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o);
13820 return nativeResponseValue;
13822 // void CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res);
13824 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
13825 if(!isWasmInitialized) {
13826 throw new Error("initializeWasm() must be awaited first!");
13828 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res);
13829 // debug statements here
13831 // uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
13833 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13834 if(!isWasmInitialized) {
13835 throw new Error("initializeWasm() must be awaited first!");
13837 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
13838 return nativeResponseValue;
13840 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
13842 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13843 if(!isWasmInitialized) {
13844 throw new Error("initializeWasm() must be awaited first!");
13846 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig);
13847 return nativeResponseValue;
13849 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt12InvoiceFeatures o);
13851 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13852 if(!isWasmInitialized) {
13853 throw new Error("initializeWasm() must be awaited first!");
13855 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o);
13856 return nativeResponseValue;
13858 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13860 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
13861 if(!isWasmInitialized) {
13862 throw new Error("initializeWasm() must be awaited first!");
13864 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e);
13865 return nativeResponseValue;
13867 // bool CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
13869 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13870 if(!isWasmInitialized) {
13871 throw new Error("initializeWasm() must be awaited first!");
13873 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o);
13874 return nativeResponseValue;
13876 // void CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res);
13878 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
13879 if(!isWasmInitialized) {
13880 throw new Error("initializeWasm() must be awaited first!");
13882 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res);
13883 // debug statements here
13885 // uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
13887 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13888 if(!isWasmInitialized) {
13889 throw new Error("initializeWasm() must be awaited first!");
13891 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
13892 return nativeResponseValue;
13894 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
13896 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13897 if(!isWasmInitialized) {
13898 throw new Error("initializeWasm() must be awaited first!");
13900 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig);
13901 return nativeResponseValue;
13903 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
13905 export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13906 if(!isWasmInitialized) {
13907 throw new Error("initializeWasm() must be awaited first!");
13909 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
13910 return nativeResponseValue;
13912 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13914 export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
13915 if(!isWasmInitialized) {
13916 throw new Error("initializeWasm() must be awaited first!");
13918 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
13919 return nativeResponseValue;
13921 // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
13923 export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13924 if(!isWasmInitialized) {
13925 throw new Error("initializeWasm() must be awaited first!");
13927 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
13928 return nativeResponseValue;
13930 // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
13932 export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
13933 if(!isWasmInitialized) {
13934 throw new Error("initializeWasm() must be awaited first!");
13936 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
13937 // debug statements here
13939 // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
13941 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13942 if(!isWasmInitialized) {
13943 throw new Error("initializeWasm() must be awaited first!");
13945 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
13946 return nativeResponseValue;
13948 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
13950 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
13951 if(!isWasmInitialized) {
13952 throw new Error("initializeWasm() must be awaited first!");
13954 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
13955 return nativeResponseValue;
13957 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
13959 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
13960 if(!isWasmInitialized) {
13961 throw new Error("initializeWasm() must be awaited first!");
13963 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
13964 return nativeResponseValue;
13966 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
13968 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
13969 if(!isWasmInitialized) {
13970 throw new Error("initializeWasm() must be awaited first!");
13972 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
13973 return nativeResponseValue;
13975 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
13977 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13978 if(!isWasmInitialized) {
13979 throw new Error("initializeWasm() must be awaited first!");
13981 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
13982 return nativeResponseValue;
13984 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
13986 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
13987 if(!isWasmInitialized) {
13988 throw new Error("initializeWasm() must be awaited first!");
13990 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
13991 // debug statements here
13993 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
13995 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13996 if(!isWasmInitialized) {
13997 throw new Error("initializeWasm() must be awaited first!");
13999 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
14000 return nativeResponseValue;
14002 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
14004 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14005 if(!isWasmInitialized) {
14006 throw new Error("initializeWasm() must be awaited first!");
14008 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
14009 return nativeResponseValue;
14011 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_ok(struct LDKOffer o);
14013 export function CResult_OfferBolt12ParseErrorZ_ok(o: bigint): bigint {
14014 if(!isWasmInitialized) {
14015 throw new Error("initializeWasm() must be awaited first!");
14017 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_ok(o);
14018 return nativeResponseValue;
14020 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
14022 export function CResult_OfferBolt12ParseErrorZ_err(e: bigint): bigint {
14023 if(!isWasmInitialized) {
14024 throw new Error("initializeWasm() must be awaited first!");
14026 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_err(e);
14027 return nativeResponseValue;
14029 // bool CResult_OfferBolt12ParseErrorZ_is_ok(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR o);
14031 export function CResult_OfferBolt12ParseErrorZ_is_ok(o: bigint): boolean {
14032 if(!isWasmInitialized) {
14033 throw new Error("initializeWasm() must be awaited first!");
14035 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_is_ok(o);
14036 return nativeResponseValue;
14038 // void CResult_OfferBolt12ParseErrorZ_free(struct LDKCResult_OfferBolt12ParseErrorZ _res);
14040 export function CResult_OfferBolt12ParseErrorZ_free(_res: bigint): void {
14041 if(!isWasmInitialized) {
14042 throw new Error("initializeWasm() must be awaited first!");
14044 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_free(_res);
14045 // debug statements here
14047 // uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg);
14049 export function CResult_OfferBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
14050 if(!isWasmInitialized) {
14051 throw new Error("initializeWasm() must be awaited first!");
14053 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(arg);
14054 return nativeResponseValue;
14056 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_clone(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR orig);
14058 export function CResult_OfferBolt12ParseErrorZ_clone(orig: bigint): bigint {
14059 if(!isWasmInitialized) {
14060 throw new Error("initializeWasm() must be awaited first!");
14062 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone(orig);
14063 return nativeResponseValue;
14065 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_ok(struct LDKPublicKey o);
14067 export function CResult_PublicKeySecp256k1ErrorZ_ok(o: number): bigint {
14068 if(!isWasmInitialized) {
14069 throw new Error("initializeWasm() must be awaited first!");
14071 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_ok(o);
14072 return nativeResponseValue;
14074 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
14076 export function CResult_PublicKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
14077 if(!isWasmInitialized) {
14078 throw new Error("initializeWasm() must be awaited first!");
14080 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_err(e);
14081 return nativeResponseValue;
14083 // bool CResult_PublicKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR o);
14085 export function CResult_PublicKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
14086 if(!isWasmInitialized) {
14087 throw new Error("initializeWasm() must be awaited first!");
14089 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_is_ok(o);
14090 return nativeResponseValue;
14092 // void CResult_PublicKeySecp256k1ErrorZ_free(struct LDKCResult_PublicKeySecp256k1ErrorZ _res);
14094 export function CResult_PublicKeySecp256k1ErrorZ_free(_res: bigint): void {
14095 if(!isWasmInitialized) {
14096 throw new Error("initializeWasm() must be awaited first!");
14098 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_free(_res);
14099 // debug statements here
14101 // uint64_t CResult_PublicKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR arg);
14103 export function CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
14104 if(!isWasmInitialized) {
14105 throw new Error("initializeWasm() must be awaited first!");
14107 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg);
14108 return nativeResponseValue;
14110 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_clone(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR orig);
14112 export function CResult_PublicKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
14113 if(!isWasmInitialized) {
14114 throw new Error("initializeWasm() must be awaited first!");
14116 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone(orig);
14117 return nativeResponseValue;
14119 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
14121 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
14122 if(!isWasmInitialized) {
14123 throw new Error("initializeWasm() must be awaited first!");
14125 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
14126 return nativeResponseValue;
14128 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
14130 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
14131 if(!isWasmInitialized) {
14132 throw new Error("initializeWasm() must be awaited first!");
14134 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
14135 return nativeResponseValue;
14137 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
14139 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
14140 if(!isWasmInitialized) {
14141 throw new Error("initializeWasm() must be awaited first!");
14143 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
14144 return nativeResponseValue;
14146 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
14148 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
14149 if(!isWasmInitialized) {
14150 throw new Error("initializeWasm() must be awaited first!");
14152 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
14153 // debug statements here
14155 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
14157 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14158 if(!isWasmInitialized) {
14159 throw new Error("initializeWasm() must be awaited first!");
14161 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
14162 return nativeResponseValue;
14164 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
14166 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
14167 if(!isWasmInitialized) {
14168 throw new Error("initializeWasm() must be awaited first!");
14170 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
14171 return nativeResponseValue;
14173 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
14175 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
14176 if(!isWasmInitialized) {
14177 throw new Error("initializeWasm() must be awaited first!");
14179 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
14180 return nativeResponseValue;
14182 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
14184 export function COption_NetworkUpdateZ_none(): bigint {
14185 if(!isWasmInitialized) {
14186 throw new Error("initializeWasm() must be awaited first!");
14188 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
14189 return nativeResponseValue;
14191 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
14193 export function COption_NetworkUpdateZ_free(_res: bigint): void {
14194 if(!isWasmInitialized) {
14195 throw new Error("initializeWasm() must be awaited first!");
14197 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
14198 // debug statements here
14200 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
14202 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
14203 if(!isWasmInitialized) {
14204 throw new Error("initializeWasm() must be awaited first!");
14206 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
14207 return nativeResponseValue;
14209 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
14211 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
14212 if(!isWasmInitialized) {
14213 throw new Error("initializeWasm() must be awaited first!");
14215 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
14216 return nativeResponseValue;
14218 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
14220 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
14221 if(!isWasmInitialized) {
14222 throw new Error("initializeWasm() must be awaited first!");
14224 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
14225 return nativeResponseValue;
14227 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
14229 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
14230 if(!isWasmInitialized) {
14231 throw new Error("initializeWasm() must be awaited first!");
14233 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
14234 return nativeResponseValue;
14236 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
14238 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
14239 if(!isWasmInitialized) {
14240 throw new Error("initializeWasm() must be awaited first!");
14242 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
14243 return nativeResponseValue;
14245 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
14247 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
14248 if(!isWasmInitialized) {
14249 throw new Error("initializeWasm() must be awaited first!");
14251 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
14252 // debug statements here
14254 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
14256 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14257 if(!isWasmInitialized) {
14258 throw new Error("initializeWasm() must be awaited first!");
14260 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
14261 return nativeResponseValue;
14263 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
14265 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
14266 if(!isWasmInitialized) {
14267 throw new Error("initializeWasm() must be awaited first!");
14269 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
14270 return nativeResponseValue;
14272 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_some(struct LDKUtxoLookup o);
14274 export function COption_UtxoLookupZ_some(o: bigint): bigint {
14275 if(!isWasmInitialized) {
14276 throw new Error("initializeWasm() must be awaited first!");
14278 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_some(o);
14279 return nativeResponseValue;
14281 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_none(void);
14283 export function COption_UtxoLookupZ_none(): bigint {
14284 if(!isWasmInitialized) {
14285 throw new Error("initializeWasm() must be awaited first!");
14287 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_none();
14288 return nativeResponseValue;
14290 // void COption_UtxoLookupZ_free(struct LDKCOption_UtxoLookupZ _res);
14292 export function COption_UtxoLookupZ_free(_res: bigint): void {
14293 if(!isWasmInitialized) {
14294 throw new Error("initializeWasm() must be awaited first!");
14296 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_free(_res);
14297 // debug statements here
14299 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
14301 export function CResult_NoneLightningErrorZ_ok(): bigint {
14302 if(!isWasmInitialized) {
14303 throw new Error("initializeWasm() must be awaited first!");
14305 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
14306 return nativeResponseValue;
14308 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
14310 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
14311 if(!isWasmInitialized) {
14312 throw new Error("initializeWasm() must be awaited first!");
14314 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
14315 return nativeResponseValue;
14317 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
14319 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
14320 if(!isWasmInitialized) {
14321 throw new Error("initializeWasm() must be awaited first!");
14323 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
14324 return nativeResponseValue;
14326 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
14328 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
14329 if(!isWasmInitialized) {
14330 throw new Error("initializeWasm() must be awaited first!");
14332 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
14333 // debug statements here
14335 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
14337 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
14338 if(!isWasmInitialized) {
14339 throw new Error("initializeWasm() must be awaited first!");
14341 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
14342 return nativeResponseValue;
14344 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
14346 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
14347 if(!isWasmInitialized) {
14348 throw new Error("initializeWasm() must be awaited first!");
14350 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
14351 return nativeResponseValue;
14353 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
14355 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
14356 if(!isWasmInitialized) {
14357 throw new Error("initializeWasm() must be awaited first!");
14359 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
14360 return nativeResponseValue;
14362 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
14364 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
14365 if(!isWasmInitialized) {
14366 throw new Error("initializeWasm() must be awaited first!");
14368 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
14369 return nativeResponseValue;
14371 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
14373 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
14374 if(!isWasmInitialized) {
14375 throw new Error("initializeWasm() must be awaited first!");
14377 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
14378 return nativeResponseValue;
14380 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
14382 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
14383 if(!isWasmInitialized) {
14384 throw new Error("initializeWasm() must be awaited first!");
14386 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
14387 // debug statements here
14389 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
14391 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
14392 if(!isWasmInitialized) {
14393 throw new Error("initializeWasm() must be awaited first!");
14395 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
14396 return nativeResponseValue;
14398 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
14400 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
14401 if(!isWasmInitialized) {
14402 throw new Error("initializeWasm() must be awaited first!");
14404 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
14405 return nativeResponseValue;
14407 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
14409 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
14410 if(!isWasmInitialized) {
14411 throw new Error("initializeWasm() must be awaited first!");
14413 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
14414 return nativeResponseValue;
14416 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
14418 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
14419 if(!isWasmInitialized) {
14420 throw new Error("initializeWasm() must be awaited first!");
14422 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
14423 return nativeResponseValue;
14425 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
14427 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
14428 if(!isWasmInitialized) {
14429 throw new Error("initializeWasm() must be awaited first!");
14431 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
14432 return nativeResponseValue;
14434 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
14436 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
14437 if(!isWasmInitialized) {
14438 throw new Error("initializeWasm() must be awaited first!");
14440 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
14441 // debug statements here
14443 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
14445 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
14446 if(!isWasmInitialized) {
14447 throw new Error("initializeWasm() must be awaited first!");
14449 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
14450 return nativeResponseValue;
14452 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
14454 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
14455 if(!isWasmInitialized) {
14456 throw new Error("initializeWasm() must be awaited first!");
14458 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
14459 return nativeResponseValue;
14461 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
14463 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
14464 if(!isWasmInitialized) {
14465 throw new Error("initializeWasm() must be awaited first!");
14467 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
14468 // debug statements here
14470 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
14472 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
14473 if(!isWasmInitialized) {
14474 throw new Error("initializeWasm() must be awaited first!");
14476 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
14477 return nativeResponseValue;
14479 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
14481 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
14482 if(!isWasmInitialized) {
14483 throw new Error("initializeWasm() must be awaited first!");
14485 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
14486 return nativeResponseValue;
14488 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
14490 export function CVec_MessageSendEventZ_free(_res: number): void {
14491 if(!isWasmInitialized) {
14492 throw new Error("initializeWasm() must be awaited first!");
14494 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
14495 // debug statements here
14497 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
14499 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
14500 if(!isWasmInitialized) {
14501 throw new Error("initializeWasm() must be awaited first!");
14503 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
14504 return nativeResponseValue;
14506 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
14508 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
14509 if(!isWasmInitialized) {
14510 throw new Error("initializeWasm() must be awaited first!");
14512 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
14513 return nativeResponseValue;
14515 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
14517 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
14518 if(!isWasmInitialized) {
14519 throw new Error("initializeWasm() must be awaited first!");
14521 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
14522 return nativeResponseValue;
14524 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
14526 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
14527 if(!isWasmInitialized) {
14528 throw new Error("initializeWasm() must be awaited first!");
14530 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
14531 // debug statements here
14533 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
14535 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14536 if(!isWasmInitialized) {
14537 throw new Error("initializeWasm() must be awaited first!");
14539 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
14540 return nativeResponseValue;
14542 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
14544 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
14545 if(!isWasmInitialized) {
14546 throw new Error("initializeWasm() must be awaited first!");
14548 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
14549 return nativeResponseValue;
14551 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
14553 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
14554 if(!isWasmInitialized) {
14555 throw new Error("initializeWasm() must be awaited first!");
14557 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
14558 return nativeResponseValue;
14560 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
14562 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
14563 if(!isWasmInitialized) {
14564 throw new Error("initializeWasm() must be awaited first!");
14566 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
14567 return nativeResponseValue;
14569 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
14571 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
14572 if(!isWasmInitialized) {
14573 throw new Error("initializeWasm() must be awaited first!");
14575 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
14576 return nativeResponseValue;
14578 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
14580 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
14581 if(!isWasmInitialized) {
14582 throw new Error("initializeWasm() must be awaited first!");
14584 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
14585 // debug statements here
14587 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
14589 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14590 if(!isWasmInitialized) {
14591 throw new Error("initializeWasm() must be awaited first!");
14593 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
14594 return nativeResponseValue;
14596 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
14598 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
14599 if(!isWasmInitialized) {
14600 throw new Error("initializeWasm() must be awaited first!");
14602 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
14603 return nativeResponseValue;
14605 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
14607 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
14608 if(!isWasmInitialized) {
14609 throw new Error("initializeWasm() must be awaited first!");
14611 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
14612 return nativeResponseValue;
14614 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
14616 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
14617 if(!isWasmInitialized) {
14618 throw new Error("initializeWasm() must be awaited first!");
14620 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
14621 return nativeResponseValue;
14623 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
14625 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
14626 if(!isWasmInitialized) {
14627 throw new Error("initializeWasm() must be awaited first!");
14629 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
14630 return nativeResponseValue;
14632 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
14634 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
14635 if(!isWasmInitialized) {
14636 throw new Error("initializeWasm() must be awaited first!");
14638 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
14639 // debug statements here
14641 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
14643 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14644 if(!isWasmInitialized) {
14645 throw new Error("initializeWasm() must be awaited first!");
14647 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
14648 return nativeResponseValue;
14650 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
14652 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
14653 if(!isWasmInitialized) {
14654 throw new Error("initializeWasm() must be awaited first!");
14656 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
14657 return nativeResponseValue;
14659 // void CVec_SocketAddressZ_free(struct LDKCVec_SocketAddressZ _res);
14661 export function CVec_SocketAddressZ_free(_res: number): void {
14662 if(!isWasmInitialized) {
14663 throw new Error("initializeWasm() must be awaited first!");
14665 const nativeResponseValue = wasm.TS_CVec_SocketAddressZ_free(_res);
14666 // debug statements here
14668 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
14670 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
14671 if(!isWasmInitialized) {
14672 throw new Error("initializeWasm() must be awaited first!");
14674 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
14675 return nativeResponseValue;
14677 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
14679 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
14680 if(!isWasmInitialized) {
14681 throw new Error("initializeWasm() must be awaited first!");
14683 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
14684 return nativeResponseValue;
14686 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
14688 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
14689 if(!isWasmInitialized) {
14690 throw new Error("initializeWasm() must be awaited first!");
14692 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
14693 return nativeResponseValue;
14695 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
14697 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
14698 if(!isWasmInitialized) {
14699 throw new Error("initializeWasm() must be awaited first!");
14701 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
14702 // debug statements here
14704 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
14706 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14707 if(!isWasmInitialized) {
14708 throw new Error("initializeWasm() must be awaited first!");
14710 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
14711 return nativeResponseValue;
14713 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
14715 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
14716 if(!isWasmInitialized) {
14717 throw new Error("initializeWasm() must be awaited first!");
14719 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
14720 return nativeResponseValue;
14722 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
14724 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
14725 if(!isWasmInitialized) {
14726 throw new Error("initializeWasm() must be awaited first!");
14728 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
14729 return nativeResponseValue;
14731 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
14733 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
14734 if(!isWasmInitialized) {
14735 throw new Error("initializeWasm() must be awaited first!");
14737 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
14738 return nativeResponseValue;
14740 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
14742 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
14743 if(!isWasmInitialized) {
14744 throw new Error("initializeWasm() must be awaited first!");
14746 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
14747 return nativeResponseValue;
14749 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
14751 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
14752 if(!isWasmInitialized) {
14753 throw new Error("initializeWasm() must be awaited first!");
14755 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
14756 // debug statements here
14758 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
14760 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14761 if(!isWasmInitialized) {
14762 throw new Error("initializeWasm() must be awaited first!");
14764 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
14765 return nativeResponseValue;
14767 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
14769 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
14770 if(!isWasmInitialized) {
14771 throw new Error("initializeWasm() must be awaited first!");
14773 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
14774 return nativeResponseValue;
14776 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
14778 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
14779 if(!isWasmInitialized) {
14780 throw new Error("initializeWasm() must be awaited first!");
14782 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
14783 return nativeResponseValue;
14785 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
14787 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
14788 if(!isWasmInitialized) {
14789 throw new Error("initializeWasm() must be awaited first!");
14791 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
14792 return nativeResponseValue;
14794 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
14796 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
14797 if(!isWasmInitialized) {
14798 throw new Error("initializeWasm() must be awaited first!");
14800 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
14801 return nativeResponseValue;
14803 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
14805 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
14806 if(!isWasmInitialized) {
14807 throw new Error("initializeWasm() must be awaited first!");
14809 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
14810 // debug statements here
14812 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
14814 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14815 if(!isWasmInitialized) {
14816 throw new Error("initializeWasm() must be awaited first!");
14818 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
14819 return nativeResponseValue;
14821 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
14823 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
14824 if(!isWasmInitialized) {
14825 throw new Error("initializeWasm() must be awaited first!");
14827 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
14828 return nativeResponseValue;
14830 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
14832 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
14833 if(!isWasmInitialized) {
14834 throw new Error("initializeWasm() must be awaited first!");
14836 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
14837 return nativeResponseValue;
14839 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
14841 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
14842 if(!isWasmInitialized) {
14843 throw new Error("initializeWasm() must be awaited first!");
14845 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
14846 return nativeResponseValue;
14848 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
14850 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
14851 if(!isWasmInitialized) {
14852 throw new Error("initializeWasm() must be awaited first!");
14854 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
14855 return nativeResponseValue;
14857 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
14859 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
14860 if(!isWasmInitialized) {
14861 throw new Error("initializeWasm() must be awaited first!");
14863 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
14864 // debug statements here
14866 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_some(struct LDKCVec_SocketAddressZ o);
14868 export function COption_CVec_SocketAddressZZ_some(o: number): bigint {
14869 if(!isWasmInitialized) {
14870 throw new Error("initializeWasm() must be awaited first!");
14872 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_some(o);
14873 return nativeResponseValue;
14875 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_none(void);
14877 export function COption_CVec_SocketAddressZZ_none(): bigint {
14878 if(!isWasmInitialized) {
14879 throw new Error("initializeWasm() must be awaited first!");
14881 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_none();
14882 return nativeResponseValue;
14884 // void COption_CVec_SocketAddressZZ_free(struct LDKCOption_CVec_SocketAddressZZ _res);
14886 export function COption_CVec_SocketAddressZZ_free(_res: bigint): void {
14887 if(!isWasmInitialized) {
14888 throw new Error("initializeWasm() must be awaited first!");
14890 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_free(_res);
14891 // debug statements here
14893 // uint64_t COption_CVec_SocketAddressZZ_clone_ptr(LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR arg);
14895 export function COption_CVec_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
14896 if(!isWasmInitialized) {
14897 throw new Error("initializeWasm() must be awaited first!");
14899 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone_ptr(arg);
14900 return nativeResponseValue;
14902 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_clone(const struct LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR orig);
14904 export function COption_CVec_SocketAddressZZ_clone(orig: bigint): bigint {
14905 if(!isWasmInitialized) {
14906 throw new Error("initializeWasm() must be awaited first!");
14908 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone(orig);
14909 return nativeResponseValue;
14911 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_ok(struct LDKChannelDerivationParameters o);
14913 export function CResult_ChannelDerivationParametersDecodeErrorZ_ok(o: bigint): bigint {
14914 if(!isWasmInitialized) {
14915 throw new Error("initializeWasm() must be awaited first!");
14917 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok(o);
14918 return nativeResponseValue;
14920 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_err(struct LDKDecodeError e);
14922 export function CResult_ChannelDerivationParametersDecodeErrorZ_err(e: bigint): bigint {
14923 if(!isWasmInitialized) {
14924 throw new Error("initializeWasm() must be awaited first!");
14926 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_err(e);
14927 return nativeResponseValue;
14929 // bool CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR o);
14931 export function CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o: bigint): boolean {
14932 if(!isWasmInitialized) {
14933 throw new Error("initializeWasm() must be awaited first!");
14935 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o);
14936 return nativeResponseValue;
14938 // void CResult_ChannelDerivationParametersDecodeErrorZ_free(struct LDKCResult_ChannelDerivationParametersDecodeErrorZ _res);
14940 export function CResult_ChannelDerivationParametersDecodeErrorZ_free(_res: bigint): void {
14941 if(!isWasmInitialized) {
14942 throw new Error("initializeWasm() must be awaited first!");
14944 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_free(_res);
14945 // debug statements here
14947 // uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg);
14949 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14950 if(!isWasmInitialized) {
14951 throw new Error("initializeWasm() must be awaited first!");
14953 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg);
14954 return nativeResponseValue;
14956 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR orig);
14958 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig: bigint): bigint {
14959 if(!isWasmInitialized) {
14960 throw new Error("initializeWasm() must be awaited first!");
14962 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig);
14963 return nativeResponseValue;
14965 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_ok(struct LDKHTLCDescriptor o);
14967 export function CResult_HTLCDescriptorDecodeErrorZ_ok(o: bigint): bigint {
14968 if(!isWasmInitialized) {
14969 throw new Error("initializeWasm() must be awaited first!");
14971 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_ok(o);
14972 return nativeResponseValue;
14974 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
14976 export function CResult_HTLCDescriptorDecodeErrorZ_err(e: bigint): bigint {
14977 if(!isWasmInitialized) {
14978 throw new Error("initializeWasm() must be awaited first!");
14980 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_err(e);
14981 return nativeResponseValue;
14983 // bool CResult_HTLCDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR o);
14985 export function CResult_HTLCDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
14986 if(!isWasmInitialized) {
14987 throw new Error("initializeWasm() must be awaited first!");
14989 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok(o);
14990 return nativeResponseValue;
14992 // void CResult_HTLCDescriptorDecodeErrorZ_free(struct LDKCResult_HTLCDescriptorDecodeErrorZ _res);
14994 export function CResult_HTLCDescriptorDecodeErrorZ_free(_res: bigint): void {
14995 if(!isWasmInitialized) {
14996 throw new Error("initializeWasm() must be awaited first!");
14998 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_free(_res);
14999 // debug statements here
15001 // uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg);
15003 export function CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15004 if(!isWasmInitialized) {
15005 throw new Error("initializeWasm() must be awaited first!");
15007 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg);
15008 return nativeResponseValue;
15010 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_clone(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR orig);
15012 export function CResult_HTLCDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
15013 if(!isWasmInitialized) {
15014 throw new Error("initializeWasm() must be awaited first!");
15016 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone(orig);
15017 return nativeResponseValue;
15019 // void CVec_HTLCOutputInCommitmentZ_free(struct LDKCVec_HTLCOutputInCommitmentZ _res);
15021 export function CVec_HTLCOutputInCommitmentZ_free(_res: number): void {
15022 if(!isWasmInitialized) {
15023 throw new Error("initializeWasm() must be awaited first!");
15025 const nativeResponseValue = wasm.TS_CVec_HTLCOutputInCommitmentZ_free(_res);
15026 // debug statements here
15028 // void CVec_HTLCDescriptorZ_free(struct LDKCVec_HTLCDescriptorZ _res);
15030 export function CVec_HTLCDescriptorZ_free(_res: number): void {
15031 if(!isWasmInitialized) {
15032 throw new Error("initializeWasm() must be awaited first!");
15034 const nativeResponseValue = wasm.TS_CVec_HTLCDescriptorZ_free(_res);
15035 // debug statements here
15037 // void CVec_UtxoZ_free(struct LDKCVec_UtxoZ _res);
15039 export function CVec_UtxoZ_free(_res: number): void {
15040 if(!isWasmInitialized) {
15041 throw new Error("initializeWasm() must be awaited first!");
15043 const nativeResponseValue = wasm.TS_CVec_UtxoZ_free(_res);
15044 // debug statements here
15046 // struct LDKCOption_TxOutZ COption_TxOutZ_some(struct LDKTxOut o);
15048 export function COption_TxOutZ_some(o: bigint): bigint {
15049 if(!isWasmInitialized) {
15050 throw new Error("initializeWasm() must be awaited first!");
15052 const nativeResponseValue = wasm.TS_COption_TxOutZ_some(o);
15053 return nativeResponseValue;
15055 // struct LDKCOption_TxOutZ COption_TxOutZ_none(void);
15057 export function COption_TxOutZ_none(): bigint {
15058 if(!isWasmInitialized) {
15059 throw new Error("initializeWasm() must be awaited first!");
15061 const nativeResponseValue = wasm.TS_COption_TxOutZ_none();
15062 return nativeResponseValue;
15064 // void COption_TxOutZ_free(struct LDKCOption_TxOutZ _res);
15066 export function COption_TxOutZ_free(_res: bigint): void {
15067 if(!isWasmInitialized) {
15068 throw new Error("initializeWasm() must be awaited first!");
15070 const nativeResponseValue = wasm.TS_COption_TxOutZ_free(_res);
15071 // debug statements here
15073 // uint64_t COption_TxOutZ_clone_ptr(LDKCOption_TxOutZ *NONNULL_PTR arg);
15075 export function COption_TxOutZ_clone_ptr(arg: bigint): bigint {
15076 if(!isWasmInitialized) {
15077 throw new Error("initializeWasm() must be awaited first!");
15079 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone_ptr(arg);
15080 return nativeResponseValue;
15082 // struct LDKCOption_TxOutZ COption_TxOutZ_clone(const struct LDKCOption_TxOutZ *NONNULL_PTR orig);
15084 export function COption_TxOutZ_clone(orig: bigint): bigint {
15085 if(!isWasmInitialized) {
15086 throw new Error("initializeWasm() must be awaited first!");
15088 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone(orig);
15089 return nativeResponseValue;
15091 // void CVec_InputZ_free(struct LDKCVec_InputZ _res);
15093 export function CVec_InputZ_free(_res: number): void {
15094 if(!isWasmInitialized) {
15095 throw new Error("initializeWasm() must be awaited first!");
15097 const nativeResponseValue = wasm.TS_CVec_InputZ_free(_res);
15098 // debug statements here
15100 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_ok(struct LDKCoinSelection o);
15102 export function CResult_CoinSelectionNoneZ_ok(o: bigint): bigint {
15103 if(!isWasmInitialized) {
15104 throw new Error("initializeWasm() must be awaited first!");
15106 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_ok(o);
15107 return nativeResponseValue;
15109 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_err(void);
15111 export function CResult_CoinSelectionNoneZ_err(): bigint {
15112 if(!isWasmInitialized) {
15113 throw new Error("initializeWasm() must be awaited first!");
15115 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_err();
15116 return nativeResponseValue;
15118 // bool CResult_CoinSelectionNoneZ_is_ok(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR o);
15120 export function CResult_CoinSelectionNoneZ_is_ok(o: bigint): boolean {
15121 if(!isWasmInitialized) {
15122 throw new Error("initializeWasm() must be awaited first!");
15124 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_is_ok(o);
15125 return nativeResponseValue;
15127 // void CResult_CoinSelectionNoneZ_free(struct LDKCResult_CoinSelectionNoneZ _res);
15129 export function CResult_CoinSelectionNoneZ_free(_res: bigint): void {
15130 if(!isWasmInitialized) {
15131 throw new Error("initializeWasm() must be awaited first!");
15133 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_free(_res);
15134 // debug statements here
15136 // uint64_t CResult_CoinSelectionNoneZ_clone_ptr(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR arg);
15138 export function CResult_CoinSelectionNoneZ_clone_ptr(arg: bigint): bigint {
15139 if(!isWasmInitialized) {
15140 throw new Error("initializeWasm() must be awaited first!");
15142 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone_ptr(arg);
15143 return nativeResponseValue;
15145 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_clone(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR orig);
15147 export function CResult_CoinSelectionNoneZ_clone(orig: bigint): bigint {
15148 if(!isWasmInitialized) {
15149 throw new Error("initializeWasm() must be awaited first!");
15151 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone(orig);
15152 return nativeResponseValue;
15154 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_ok(struct LDKCVec_UtxoZ o);
15156 export function CResult_CVec_UtxoZNoneZ_ok(o: number): bigint {
15157 if(!isWasmInitialized) {
15158 throw new Error("initializeWasm() must be awaited first!");
15160 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_ok(o);
15161 return nativeResponseValue;
15163 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_err(void);
15165 export function CResult_CVec_UtxoZNoneZ_err(): bigint {
15166 if(!isWasmInitialized) {
15167 throw new Error("initializeWasm() must be awaited first!");
15169 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_err();
15170 return nativeResponseValue;
15172 // bool CResult_CVec_UtxoZNoneZ_is_ok(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR o);
15174 export function CResult_CVec_UtxoZNoneZ_is_ok(o: bigint): boolean {
15175 if(!isWasmInitialized) {
15176 throw new Error("initializeWasm() must be awaited first!");
15178 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_is_ok(o);
15179 return nativeResponseValue;
15181 // void CResult_CVec_UtxoZNoneZ_free(struct LDKCResult_CVec_UtxoZNoneZ _res);
15183 export function CResult_CVec_UtxoZNoneZ_free(_res: bigint): void {
15184 if(!isWasmInitialized) {
15185 throw new Error("initializeWasm() must be awaited first!");
15187 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_free(_res);
15188 // debug statements here
15190 // uint64_t CResult_CVec_UtxoZNoneZ_clone_ptr(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR arg);
15192 export function CResult_CVec_UtxoZNoneZ_clone_ptr(arg: bigint): bigint {
15193 if(!isWasmInitialized) {
15194 throw new Error("initializeWasm() must be awaited first!");
15196 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone_ptr(arg);
15197 return nativeResponseValue;
15199 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_clone(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR orig);
15201 export function CResult_CVec_UtxoZNoneZ_clone(orig: bigint): bigint {
15202 if(!isWasmInitialized) {
15203 throw new Error("initializeWasm() must be awaited first!");
15205 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone(orig);
15206 return nativeResponseValue;
15208 // uint64_t C2Tuple_u64u16Z_clone_ptr(LDKC2Tuple_u64u16Z *NONNULL_PTR arg);
15210 export function C2Tuple_u64u16Z_clone_ptr(arg: bigint): bigint {
15211 if(!isWasmInitialized) {
15212 throw new Error("initializeWasm() must be awaited first!");
15214 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone_ptr(arg);
15215 return nativeResponseValue;
15217 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_clone(const struct LDKC2Tuple_u64u16Z *NONNULL_PTR orig);
15219 export function C2Tuple_u64u16Z_clone(orig: bigint): bigint {
15220 if(!isWasmInitialized) {
15221 throw new Error("initializeWasm() must be awaited first!");
15223 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone(orig);
15224 return nativeResponseValue;
15226 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_new(uint64_t a, uint16_t b);
15228 export function C2Tuple_u64u16Z_new(a: bigint, b: number): bigint {
15229 if(!isWasmInitialized) {
15230 throw new Error("initializeWasm() must be awaited first!");
15232 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_new(a, b);
15233 return nativeResponseValue;
15235 // void C2Tuple_u64u16Z_free(struct LDKC2Tuple_u64u16Z _res);
15237 export function C2Tuple_u64u16Z_free(_res: bigint): void {
15238 if(!isWasmInitialized) {
15239 throw new Error("initializeWasm() must be awaited first!");
15241 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_free(_res);
15242 // debug statements here
15244 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_some(struct LDKC2Tuple_u64u16Z o);
15246 export function COption_C2Tuple_u64u16ZZ_some(o: bigint): bigint {
15247 if(!isWasmInitialized) {
15248 throw new Error("initializeWasm() must be awaited first!");
15250 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_some(o);
15251 return nativeResponseValue;
15253 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_none(void);
15255 export function COption_C2Tuple_u64u16ZZ_none(): bigint {
15256 if(!isWasmInitialized) {
15257 throw new Error("initializeWasm() must be awaited first!");
15259 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_none();
15260 return nativeResponseValue;
15262 // void COption_C2Tuple_u64u16ZZ_free(struct LDKCOption_C2Tuple_u64u16ZZ _res);
15264 export function COption_C2Tuple_u64u16ZZ_free(_res: bigint): void {
15265 if(!isWasmInitialized) {
15266 throw new Error("initializeWasm() must be awaited first!");
15268 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_free(_res);
15269 // debug statements here
15271 // uint64_t COption_C2Tuple_u64u16ZZ_clone_ptr(LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR arg);
15273 export function COption_C2Tuple_u64u16ZZ_clone_ptr(arg: bigint): bigint {
15274 if(!isWasmInitialized) {
15275 throw new Error("initializeWasm() must be awaited first!");
15277 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone_ptr(arg);
15278 return nativeResponseValue;
15280 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_clone(const struct LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR orig);
15282 export function COption_C2Tuple_u64u16ZZ_clone(orig: bigint): bigint {
15283 if(!isWasmInitialized) {
15284 throw new Error("initializeWasm() must be awaited first!");
15286 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone(orig);
15287 return nativeResponseValue;
15289 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
15291 export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
15292 if(!isWasmInitialized) {
15293 throw new Error("initializeWasm() must be awaited first!");
15295 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
15296 return nativeResponseValue;
15298 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
15300 export function COption_ChannelShutdownStateZ_none(): bigint {
15301 if(!isWasmInitialized) {
15302 throw new Error("initializeWasm() must be awaited first!");
15304 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
15305 return nativeResponseValue;
15307 // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
15309 export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
15310 if(!isWasmInitialized) {
15311 throw new Error("initializeWasm() must be awaited first!");
15313 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
15314 // debug statements here
15316 // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
15318 export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
15319 if(!isWasmInitialized) {
15320 throw new Error("initializeWasm() must be awaited first!");
15322 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
15323 return nativeResponseValue;
15325 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
15327 export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
15328 if(!isWasmInitialized) {
15329 throw new Error("initializeWasm() must be awaited first!");
15331 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
15332 return nativeResponseValue;
15334 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
15336 export function CResult_ThirtyTwoBytesAPIErrorZ_ok(o: number): bigint {
15337 if(!isWasmInitialized) {
15338 throw new Error("initializeWasm() must be awaited first!");
15340 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_ok(o);
15341 return nativeResponseValue;
15343 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_err(struct LDKAPIError e);
15345 export function CResult_ThirtyTwoBytesAPIErrorZ_err(e: bigint): bigint {
15346 if(!isWasmInitialized) {
15347 throw new Error("initializeWasm() must be awaited first!");
15349 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_err(e);
15350 return nativeResponseValue;
15352 // bool CResult_ThirtyTwoBytesAPIErrorZ_is_ok(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR o);
15354 export function CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o: bigint): boolean {
15355 if(!isWasmInitialized) {
15356 throw new Error("initializeWasm() must be awaited first!");
15358 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o);
15359 return nativeResponseValue;
15361 // void CResult_ThirtyTwoBytesAPIErrorZ_free(struct LDKCResult_ThirtyTwoBytesAPIErrorZ _res);
15363 export function CResult_ThirtyTwoBytesAPIErrorZ_free(_res: bigint): void {
15364 if(!isWasmInitialized) {
15365 throw new Error("initializeWasm() must be awaited first!");
15367 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_free(_res);
15368 // debug statements here
15370 // uint64_t CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR arg);
15372 export function CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg: bigint): bigint {
15373 if(!isWasmInitialized) {
15374 throw new Error("initializeWasm() must be awaited first!");
15376 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg);
15377 return nativeResponseValue;
15379 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_clone(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR orig);
15381 export function CResult_ThirtyTwoBytesAPIErrorZ_clone(orig: bigint): bigint {
15382 if(!isWasmInitialized) {
15383 throw new Error("initializeWasm() must be awaited first!");
15385 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone(orig);
15386 return nativeResponseValue;
15388 // void CVec_RecentPaymentDetailsZ_free(struct LDKCVec_RecentPaymentDetailsZ _res);
15390 export function CVec_RecentPaymentDetailsZ_free(_res: number): void {
15391 if(!isWasmInitialized) {
15392 throw new Error("initializeWasm() must be awaited first!");
15394 const nativeResponseValue = wasm.TS_CVec_RecentPaymentDetailsZ_free(_res);
15395 // debug statements here
15397 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
15399 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
15400 if(!isWasmInitialized) {
15401 throw new Error("initializeWasm() must be awaited first!");
15403 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
15404 return nativeResponseValue;
15406 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
15408 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
15409 if(!isWasmInitialized) {
15410 throw new Error("initializeWasm() must be awaited first!");
15412 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
15413 return nativeResponseValue;
15415 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
15417 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
15418 if(!isWasmInitialized) {
15419 throw new Error("initializeWasm() must be awaited first!");
15421 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
15422 return nativeResponseValue;
15424 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
15426 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
15427 if(!isWasmInitialized) {
15428 throw new Error("initializeWasm() must be awaited first!");
15430 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
15431 // debug statements here
15433 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
15435 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
15436 if(!isWasmInitialized) {
15437 throw new Error("initializeWasm() must be awaited first!");
15439 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
15440 return nativeResponseValue;
15442 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
15444 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
15445 if(!isWasmInitialized) {
15446 throw new Error("initializeWasm() must be awaited first!");
15448 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
15449 return nativeResponseValue;
15451 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_ok(void);
15453 export function CResult_NoneRetryableSendFailureZ_ok(): bigint {
15454 if(!isWasmInitialized) {
15455 throw new Error("initializeWasm() must be awaited first!");
15457 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_ok();
15458 return nativeResponseValue;
15460 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
15462 export function CResult_NoneRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
15463 if(!isWasmInitialized) {
15464 throw new Error("initializeWasm() must be awaited first!");
15466 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_err(e);
15467 return nativeResponseValue;
15469 // bool CResult_NoneRetryableSendFailureZ_is_ok(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR o);
15471 export function CResult_NoneRetryableSendFailureZ_is_ok(o: bigint): boolean {
15472 if(!isWasmInitialized) {
15473 throw new Error("initializeWasm() must be awaited first!");
15475 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_is_ok(o);
15476 return nativeResponseValue;
15478 // void CResult_NoneRetryableSendFailureZ_free(struct LDKCResult_NoneRetryableSendFailureZ _res);
15480 export function CResult_NoneRetryableSendFailureZ_free(_res: bigint): void {
15481 if(!isWasmInitialized) {
15482 throw new Error("initializeWasm() must be awaited first!");
15484 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_free(_res);
15485 // debug statements here
15487 // uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg);
15489 export function CResult_NoneRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
15490 if(!isWasmInitialized) {
15491 throw new Error("initializeWasm() must be awaited first!");
15493 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone_ptr(arg);
15494 return nativeResponseValue;
15496 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_clone(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR orig);
15498 export function CResult_NoneRetryableSendFailureZ_clone(orig: bigint): bigint {
15499 if(!isWasmInitialized) {
15500 throw new Error("initializeWasm() must be awaited first!");
15502 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone(orig);
15503 return nativeResponseValue;
15505 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
15507 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o: number): bigint {
15508 if(!isWasmInitialized) {
15509 throw new Error("initializeWasm() must be awaited first!");
15511 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o);
15512 return nativeResponseValue;
15514 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
15516 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e: bigint): bigint {
15517 if(!isWasmInitialized) {
15518 throw new Error("initializeWasm() must be awaited first!");
15520 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e);
15521 return nativeResponseValue;
15523 // bool CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR o);
15525 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o: bigint): boolean {
15526 if(!isWasmInitialized) {
15527 throw new Error("initializeWasm() must be awaited first!");
15529 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o);
15530 return nativeResponseValue;
15532 // void CResult_ThirtyTwoBytesPaymentSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ _res);
15534 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res: bigint): void {
15535 if(!isWasmInitialized) {
15536 throw new Error("initializeWasm() must be awaited first!");
15538 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res);
15539 // debug statements here
15541 // uint64_t CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR arg);
15543 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
15544 if(!isWasmInitialized) {
15545 throw new Error("initializeWasm() must be awaited first!");
15547 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg);
15548 return nativeResponseValue;
15550 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR orig);
15552 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig: bigint): bigint {
15553 if(!isWasmInitialized) {
15554 throw new Error("initializeWasm() must be awaited first!");
15556 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig);
15557 return nativeResponseValue;
15559 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(struct LDKThirtyTwoBytes o);
15561 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o: number): bigint {
15562 if(!isWasmInitialized) {
15563 throw new Error("initializeWasm() must be awaited first!");
15565 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o);
15566 return nativeResponseValue;
15568 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
15570 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
15571 if(!isWasmInitialized) {
15572 throw new Error("initializeWasm() must be awaited first!");
15574 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e);
15575 return nativeResponseValue;
15577 // bool CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR o);
15579 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o: bigint): boolean {
15580 if(!isWasmInitialized) {
15581 throw new Error("initializeWasm() must be awaited first!");
15583 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o);
15584 return nativeResponseValue;
15586 // void CResult_ThirtyTwoBytesRetryableSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ _res);
15588 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res: bigint): void {
15589 if(!isWasmInitialized) {
15590 throw new Error("initializeWasm() must be awaited first!");
15592 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res);
15593 // debug statements here
15595 // uint64_t CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR arg);
15597 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
15598 if(!isWasmInitialized) {
15599 throw new Error("initializeWasm() must be awaited first!");
15601 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg);
15602 return nativeResponseValue;
15604 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR orig);
15606 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig: bigint): bigint {
15607 if(!isWasmInitialized) {
15608 throw new Error("initializeWasm() must be awaited first!");
15610 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig);
15611 return nativeResponseValue;
15613 // uint64_t C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR arg);
15615 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
15616 if(!isWasmInitialized) {
15617 throw new Error("initializeWasm() must be awaited first!");
15619 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg);
15620 return nativeResponseValue;
15622 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR orig);
15624 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig: bigint): bigint {
15625 if(!isWasmInitialized) {
15626 throw new Error("initializeWasm() must be awaited first!");
15628 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig);
15629 return nativeResponseValue;
15631 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
15633 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a: number, b: number): bigint {
15634 if(!isWasmInitialized) {
15635 throw new Error("initializeWasm() must be awaited first!");
15637 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a, b);
15638 return nativeResponseValue;
15640 // void C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ _res);
15642 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res: bigint): void {
15643 if(!isWasmInitialized) {
15644 throw new Error("initializeWasm() must be awaited first!");
15646 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res);
15647 // debug statements here
15649 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
15651 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o: bigint): bigint {
15652 if(!isWasmInitialized) {
15653 throw new Error("initializeWasm() must be awaited first!");
15655 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o);
15656 return nativeResponseValue;
15658 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
15660 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e: bigint): bigint {
15661 if(!isWasmInitialized) {
15662 throw new Error("initializeWasm() must be awaited first!");
15664 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e);
15665 return nativeResponseValue;
15667 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR o);
15669 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o: bigint): boolean {
15670 if(!isWasmInitialized) {
15671 throw new Error("initializeWasm() must be awaited first!");
15673 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o);
15674 return nativeResponseValue;
15676 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ _res);
15678 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res: bigint): void {
15679 if(!isWasmInitialized) {
15680 throw new Error("initializeWasm() must be awaited first!");
15682 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res);
15683 // debug statements here
15685 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR arg);
15687 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
15688 if(!isWasmInitialized) {
15689 throw new Error("initializeWasm() must be awaited first!");
15691 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg);
15692 return nativeResponseValue;
15694 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR orig);
15696 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig: bigint): bigint {
15697 if(!isWasmInitialized) {
15698 throw new Error("initializeWasm() must be awaited first!");
15700 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig);
15701 return nativeResponseValue;
15703 // void CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ _res);
15705 export function CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res: number): void {
15706 if(!isWasmInitialized) {
15707 throw new Error("initializeWasm() must be awaited first!");
15709 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res);
15710 // debug statements here
15712 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o);
15714 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o: number): bigint {
15715 if(!isWasmInitialized) {
15716 throw new Error("initializeWasm() must be awaited first!");
15718 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o);
15719 return nativeResponseValue;
15721 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(struct LDKProbeSendFailure e);
15723 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e: bigint): bigint {
15724 if(!isWasmInitialized) {
15725 throw new Error("initializeWasm() must be awaited first!");
15727 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e);
15728 return nativeResponseValue;
15730 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR o);
15732 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o: bigint): boolean {
15733 if(!isWasmInitialized) {
15734 throw new Error("initializeWasm() must be awaited first!");
15736 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o);
15737 return nativeResponseValue;
15739 // void CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ _res);
15741 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res: bigint): void {
15742 if(!isWasmInitialized) {
15743 throw new Error("initializeWasm() must be awaited first!");
15745 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res);
15746 // debug statements here
15748 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR arg);
15750 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg: bigint): bigint {
15751 if(!isWasmInitialized) {
15752 throw new Error("initializeWasm() must be awaited first!");
15754 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg);
15755 return nativeResponseValue;
15757 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR orig);
15759 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig: bigint): bigint {
15760 if(!isWasmInitialized) {
15761 throw new Error("initializeWasm() must be awaited first!");
15763 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig);
15764 return nativeResponseValue;
15766 // uint64_t C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR arg);
15768 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg: bigint): bigint {
15769 if(!isWasmInitialized) {
15770 throw new Error("initializeWasm() must be awaited first!");
15772 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg);
15773 return nativeResponseValue;
15775 // struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR orig);
15777 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig: bigint): bigint {
15778 if(!isWasmInitialized) {
15779 throw new Error("initializeWasm() must be awaited first!");
15781 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig);
15782 return nativeResponseValue;
15784 // struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ C2Tuple_ThirtyTwoBytesPublicKeyZ_new(struct LDKThirtyTwoBytes a, struct LDKPublicKey b);
15786 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a: number, b: number): bigint {
15787 if(!isWasmInitialized) {
15788 throw new Error("initializeWasm() must be awaited first!");
15790 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a, b);
15791 return nativeResponseValue;
15793 // void C2Tuple_ThirtyTwoBytesPublicKeyZ_free(struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ _res);
15795 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res: bigint): void {
15796 if(!isWasmInitialized) {
15797 throw new Error("initializeWasm() must be awaited first!");
15799 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res);
15800 // debug statements here
15802 // void CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ _res);
15804 export function CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res: number): void {
15805 if(!isWasmInitialized) {
15806 throw new Error("initializeWasm() must be awaited first!");
15808 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res);
15809 // debug statements here
15811 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
15813 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o: bigint): bigint {
15814 if(!isWasmInitialized) {
15815 throw new Error("initializeWasm() must be awaited first!");
15817 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o);
15818 return nativeResponseValue;
15820 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(void);
15822 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(): bigint {
15823 if(!isWasmInitialized) {
15824 throw new Error("initializeWasm() must be awaited first!");
15826 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err();
15827 return nativeResponseValue;
15829 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR o);
15831 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o: bigint): boolean {
15832 if(!isWasmInitialized) {
15833 throw new Error("initializeWasm() must be awaited first!");
15835 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o);
15836 return nativeResponseValue;
15838 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ _res);
15840 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res: bigint): void {
15841 if(!isWasmInitialized) {
15842 throw new Error("initializeWasm() must be awaited first!");
15844 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res);
15845 // debug statements here
15847 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR arg);
15849 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg: bigint): bigint {
15850 if(!isWasmInitialized) {
15851 throw new Error("initializeWasm() must be awaited first!");
15853 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg);
15854 return nativeResponseValue;
15856 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR orig);
15858 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig: bigint): bigint {
15859 if(!isWasmInitialized) {
15860 throw new Error("initializeWasm() must be awaited first!");
15862 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig);
15863 return nativeResponseValue;
15865 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
15867 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
15868 if(!isWasmInitialized) {
15869 throw new Error("initializeWasm() must be awaited first!");
15871 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
15872 return nativeResponseValue;
15874 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
15876 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
15877 if(!isWasmInitialized) {
15878 throw new Error("initializeWasm() must be awaited first!");
15880 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
15881 return nativeResponseValue;
15883 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
15885 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15886 if(!isWasmInitialized) {
15887 throw new Error("initializeWasm() must be awaited first!");
15889 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
15890 return nativeResponseValue;
15892 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
15894 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
15895 if(!isWasmInitialized) {
15896 throw new Error("initializeWasm() must be awaited first!");
15898 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
15899 // debug statements here
15901 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
15903 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15904 if(!isWasmInitialized) {
15905 throw new Error("initializeWasm() must be awaited first!");
15907 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
15908 return nativeResponseValue;
15910 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
15912 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
15913 if(!isWasmInitialized) {
15914 throw new Error("initializeWasm() must be awaited first!");
15916 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
15917 return nativeResponseValue;
15919 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
15921 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
15922 if(!isWasmInitialized) {
15923 throw new Error("initializeWasm() must be awaited first!");
15925 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
15926 return nativeResponseValue;
15928 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
15930 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
15931 if(!isWasmInitialized) {
15932 throw new Error("initializeWasm() must be awaited first!");
15934 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
15935 return nativeResponseValue;
15937 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
15939 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
15940 if(!isWasmInitialized) {
15941 throw new Error("initializeWasm() must be awaited first!");
15943 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
15944 return nativeResponseValue;
15946 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
15948 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
15949 if(!isWasmInitialized) {
15950 throw new Error("initializeWasm() must be awaited first!");
15952 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
15953 // debug statements here
15955 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
15957 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15958 if(!isWasmInitialized) {
15959 throw new Error("initializeWasm() must be awaited first!");
15961 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
15962 return nativeResponseValue;
15964 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
15966 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
15967 if(!isWasmInitialized) {
15968 throw new Error("initializeWasm() must be awaited first!");
15970 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
15971 return nativeResponseValue;
15973 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
15975 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
15976 if(!isWasmInitialized) {
15977 throw new Error("initializeWasm() must be awaited first!");
15979 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
15980 return nativeResponseValue;
15982 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
15984 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
15985 if(!isWasmInitialized) {
15986 throw new Error("initializeWasm() must be awaited first!");
15988 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
15989 return nativeResponseValue;
15991 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
15993 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
15994 if(!isWasmInitialized) {
15995 throw new Error("initializeWasm() must be awaited first!");
15997 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
15998 return nativeResponseValue;
16000 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
16002 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
16003 if(!isWasmInitialized) {
16004 throw new Error("initializeWasm() must be awaited first!");
16006 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
16007 // debug statements here
16009 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
16011 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16012 if(!isWasmInitialized) {
16013 throw new Error("initializeWasm() must be awaited first!");
16015 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
16016 return nativeResponseValue;
16018 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
16020 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
16021 if(!isWasmInitialized) {
16022 throw new Error("initializeWasm() must be awaited first!");
16024 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
16025 return nativeResponseValue;
16027 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
16029 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
16030 if(!isWasmInitialized) {
16031 throw new Error("initializeWasm() must be awaited first!");
16033 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
16034 return nativeResponseValue;
16036 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
16038 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
16039 if(!isWasmInitialized) {
16040 throw new Error("initializeWasm() must be awaited first!");
16042 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
16043 return nativeResponseValue;
16045 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
16047 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
16048 if(!isWasmInitialized) {
16049 throw new Error("initializeWasm() must be awaited first!");
16051 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
16052 return nativeResponseValue;
16054 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
16056 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
16057 if(!isWasmInitialized) {
16058 throw new Error("initializeWasm() must be awaited first!");
16060 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
16061 // debug statements here
16063 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
16065 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16066 if(!isWasmInitialized) {
16067 throw new Error("initializeWasm() must be awaited first!");
16069 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
16070 return nativeResponseValue;
16072 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
16074 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
16075 if(!isWasmInitialized) {
16076 throw new Error("initializeWasm() must be awaited first!");
16078 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
16079 return nativeResponseValue;
16081 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
16083 export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
16084 if(!isWasmInitialized) {
16085 throw new Error("initializeWasm() must be awaited first!");
16087 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
16088 return nativeResponseValue;
16090 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
16092 export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
16093 if(!isWasmInitialized) {
16094 throw new Error("initializeWasm() must be awaited first!");
16096 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
16097 return nativeResponseValue;
16099 // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
16101 export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
16102 if(!isWasmInitialized) {
16103 throw new Error("initializeWasm() must be awaited first!");
16105 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
16106 return nativeResponseValue;
16108 // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
16110 export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
16111 if(!isWasmInitialized) {
16112 throw new Error("initializeWasm() must be awaited first!");
16114 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
16115 // debug statements here
16117 // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
16119 export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16120 if(!isWasmInitialized) {
16121 throw new Error("initializeWasm() must be awaited first!");
16123 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
16124 return nativeResponseValue;
16126 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
16128 export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
16129 if(!isWasmInitialized) {
16130 throw new Error("initializeWasm() must be awaited first!");
16132 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
16133 return nativeResponseValue;
16135 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
16137 export function CVec_ChannelMonitorZ_free(_res: number): void {
16138 if(!isWasmInitialized) {
16139 throw new Error("initializeWasm() must be awaited first!");
16141 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
16142 // debug statements here
16144 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ C2Tuple_ThirtyTwoBytesChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
16146 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a: number, b: bigint): bigint {
16147 if(!isWasmInitialized) {
16148 throw new Error("initializeWasm() must be awaited first!");
16150 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a, b);
16151 return nativeResponseValue;
16153 // void C2Tuple_ThirtyTwoBytesChannelManagerZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ _res);
16155 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res: bigint): void {
16156 if(!isWasmInitialized) {
16157 throw new Error("initializeWasm() must be awaited first!");
16159 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res);
16160 // debug statements here
16162 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ o);
16164 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
16165 if(!isWasmInitialized) {
16166 throw new Error("initializeWasm() must be awaited first!");
16168 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o);
16169 return nativeResponseValue;
16171 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
16173 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
16174 if(!isWasmInitialized) {
16175 throw new Error("initializeWasm() must be awaited first!");
16177 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e);
16178 return nativeResponseValue;
16180 // bool CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR o);
16182 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
16183 if(!isWasmInitialized) {
16184 throw new Error("initializeWasm() must be awaited first!");
16186 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o);
16187 return nativeResponseValue;
16189 // void CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ _res);
16191 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res: bigint): void {
16192 if(!isWasmInitialized) {
16193 throw new Error("initializeWasm() must be awaited first!");
16195 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res);
16196 // debug statements here
16198 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_ok(struct LDKMaxDustHTLCExposure o);
16200 export function CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o: bigint): bigint {
16201 if(!isWasmInitialized) {
16202 throw new Error("initializeWasm() must be awaited first!");
16204 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o);
16205 return nativeResponseValue;
16207 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_err(struct LDKDecodeError e);
16209 export function CResult_MaxDustHTLCExposureDecodeErrorZ_err(e: bigint): bigint {
16210 if(!isWasmInitialized) {
16211 throw new Error("initializeWasm() must be awaited first!");
16213 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err(e);
16214 return nativeResponseValue;
16216 // bool CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR o);
16218 export function CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o: bigint): boolean {
16219 if(!isWasmInitialized) {
16220 throw new Error("initializeWasm() must be awaited first!");
16222 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o);
16223 return nativeResponseValue;
16225 // void CResult_MaxDustHTLCExposureDecodeErrorZ_free(struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ _res);
16227 export function CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res: bigint): void {
16228 if(!isWasmInitialized) {
16229 throw new Error("initializeWasm() must be awaited first!");
16231 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res);
16232 // debug statements here
16234 // uint64_t CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR arg);
16236 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16237 if(!isWasmInitialized) {
16238 throw new Error("initializeWasm() must be awaited first!");
16240 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg);
16241 return nativeResponseValue;
16243 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_clone(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR orig);
16245 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig: bigint): bigint {
16246 if(!isWasmInitialized) {
16247 throw new Error("initializeWasm() must be awaited first!");
16249 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig);
16250 return nativeResponseValue;
16252 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
16254 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
16255 if(!isWasmInitialized) {
16256 throw new Error("initializeWasm() must be awaited first!");
16258 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
16259 return nativeResponseValue;
16261 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
16263 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
16264 if(!isWasmInitialized) {
16265 throw new Error("initializeWasm() must be awaited first!");
16267 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
16268 return nativeResponseValue;
16270 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
16272 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
16273 if(!isWasmInitialized) {
16274 throw new Error("initializeWasm() must be awaited first!");
16276 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
16277 return nativeResponseValue;
16279 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
16281 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
16282 if(!isWasmInitialized) {
16283 throw new Error("initializeWasm() must be awaited first!");
16285 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
16286 // debug statements here
16288 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
16290 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16291 if(!isWasmInitialized) {
16292 throw new Error("initializeWasm() must be awaited first!");
16294 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
16295 return nativeResponseValue;
16297 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
16299 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
16300 if(!isWasmInitialized) {
16301 throw new Error("initializeWasm() must be awaited first!");
16303 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
16304 return nativeResponseValue;
16306 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_some(struct LDKMaxDustHTLCExposure o);
16308 export function COption_MaxDustHTLCExposureZ_some(o: bigint): bigint {
16309 if(!isWasmInitialized) {
16310 throw new Error("initializeWasm() must be awaited first!");
16312 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_some(o);
16313 return nativeResponseValue;
16315 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_none(void);
16317 export function COption_MaxDustHTLCExposureZ_none(): bigint {
16318 if(!isWasmInitialized) {
16319 throw new Error("initializeWasm() must be awaited first!");
16321 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_none();
16322 return nativeResponseValue;
16324 // void COption_MaxDustHTLCExposureZ_free(struct LDKCOption_MaxDustHTLCExposureZ _res);
16326 export function COption_MaxDustHTLCExposureZ_free(_res: bigint): void {
16327 if(!isWasmInitialized) {
16328 throw new Error("initializeWasm() must be awaited first!");
16330 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_free(_res);
16331 // debug statements here
16333 // uint64_t COption_MaxDustHTLCExposureZ_clone_ptr(LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR arg);
16335 export function COption_MaxDustHTLCExposureZ_clone_ptr(arg: bigint): bigint {
16336 if(!isWasmInitialized) {
16337 throw new Error("initializeWasm() must be awaited first!");
16339 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone_ptr(arg);
16340 return nativeResponseValue;
16342 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_clone(const struct LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR orig);
16344 export function COption_MaxDustHTLCExposureZ_clone(orig: bigint): bigint {
16345 if(!isWasmInitialized) {
16346 throw new Error("initializeWasm() must be awaited first!");
16348 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone(orig);
16349 return nativeResponseValue;
16351 // struct LDKCOption_APIErrorZ COption_APIErrorZ_some(struct LDKAPIError o);
16353 export function COption_APIErrorZ_some(o: bigint): bigint {
16354 if(!isWasmInitialized) {
16355 throw new Error("initializeWasm() must be awaited first!");
16357 const nativeResponseValue = wasm.TS_COption_APIErrorZ_some(o);
16358 return nativeResponseValue;
16360 // struct LDKCOption_APIErrorZ COption_APIErrorZ_none(void);
16362 export function COption_APIErrorZ_none(): bigint {
16363 if(!isWasmInitialized) {
16364 throw new Error("initializeWasm() must be awaited first!");
16366 const nativeResponseValue = wasm.TS_COption_APIErrorZ_none();
16367 return nativeResponseValue;
16369 // void COption_APIErrorZ_free(struct LDKCOption_APIErrorZ _res);
16371 export function COption_APIErrorZ_free(_res: bigint): void {
16372 if(!isWasmInitialized) {
16373 throw new Error("initializeWasm() must be awaited first!");
16375 const nativeResponseValue = wasm.TS_COption_APIErrorZ_free(_res);
16376 // debug statements here
16378 // uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg);
16380 export function COption_APIErrorZ_clone_ptr(arg: bigint): bigint {
16381 if(!isWasmInitialized) {
16382 throw new Error("initializeWasm() must be awaited first!");
16384 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone_ptr(arg);
16385 return nativeResponseValue;
16387 // struct LDKCOption_APIErrorZ COption_APIErrorZ_clone(const struct LDKCOption_APIErrorZ *NONNULL_PTR orig);
16389 export function COption_APIErrorZ_clone(orig: bigint): bigint {
16390 if(!isWasmInitialized) {
16391 throw new Error("initializeWasm() must be awaited first!");
16393 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone(orig);
16394 return nativeResponseValue;
16396 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_ok(struct LDKCOption_APIErrorZ o);
16398 export function CResult_COption_APIErrorZDecodeErrorZ_ok(o: bigint): bigint {
16399 if(!isWasmInitialized) {
16400 throw new Error("initializeWasm() must be awaited first!");
16402 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_ok(o);
16403 return nativeResponseValue;
16405 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_err(struct LDKDecodeError e);
16407 export function CResult_COption_APIErrorZDecodeErrorZ_err(e: bigint): bigint {
16408 if(!isWasmInitialized) {
16409 throw new Error("initializeWasm() must be awaited first!");
16411 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_err(e);
16412 return nativeResponseValue;
16414 // bool CResult_COption_APIErrorZDecodeErrorZ_is_ok(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR o);
16416 export function CResult_COption_APIErrorZDecodeErrorZ_is_ok(o: bigint): boolean {
16417 if(!isWasmInitialized) {
16418 throw new Error("initializeWasm() must be awaited first!");
16420 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(o);
16421 return nativeResponseValue;
16423 // void CResult_COption_APIErrorZDecodeErrorZ_free(struct LDKCResult_COption_APIErrorZDecodeErrorZ _res);
16425 export function CResult_COption_APIErrorZDecodeErrorZ_free(_res: bigint): void {
16426 if(!isWasmInitialized) {
16427 throw new Error("initializeWasm() must be awaited first!");
16429 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_free(_res);
16430 // debug statements here
16432 // uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg);
16434 export function CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16435 if(!isWasmInitialized) {
16436 throw new Error("initializeWasm() must be awaited first!");
16438 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg);
16439 return nativeResponseValue;
16441 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_clone(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR orig);
16443 export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigint {
16444 if(!isWasmInitialized) {
16445 throw new Error("initializeWasm() must be awaited first!");
16447 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
16448 return nativeResponseValue;
16450 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
16452 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
16453 if(!isWasmInitialized) {
16454 throw new Error("initializeWasm() must be awaited first!");
16456 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
16457 return nativeResponseValue;
16459 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16461 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
16462 if(!isWasmInitialized) {
16463 throw new Error("initializeWasm() must be awaited first!");
16465 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
16466 return nativeResponseValue;
16468 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
16470 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16471 if(!isWasmInitialized) {
16472 throw new Error("initializeWasm() must be awaited first!");
16474 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
16475 return nativeResponseValue;
16477 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
16479 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
16480 if(!isWasmInitialized) {
16481 throw new Error("initializeWasm() must be awaited first!");
16483 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
16484 // debug statements here
16486 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
16488 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16489 if(!isWasmInitialized) {
16490 throw new Error("initializeWasm() must be awaited first!");
16492 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
16493 return nativeResponseValue;
16495 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
16497 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16498 if(!isWasmInitialized) {
16499 throw new Error("initializeWasm() must be awaited first!");
16501 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
16502 return nativeResponseValue;
16504 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
16506 export function COption_MonitorEventZ_some(o: bigint): bigint {
16507 if(!isWasmInitialized) {
16508 throw new Error("initializeWasm() must be awaited first!");
16510 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
16511 return nativeResponseValue;
16513 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
16515 export function COption_MonitorEventZ_none(): bigint {
16516 if(!isWasmInitialized) {
16517 throw new Error("initializeWasm() must be awaited first!");
16519 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
16520 return nativeResponseValue;
16522 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
16524 export function COption_MonitorEventZ_free(_res: bigint): void {
16525 if(!isWasmInitialized) {
16526 throw new Error("initializeWasm() must be awaited first!");
16528 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
16529 // debug statements here
16531 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
16533 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
16534 if(!isWasmInitialized) {
16535 throw new Error("initializeWasm() must be awaited first!");
16537 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
16538 return nativeResponseValue;
16540 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
16542 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
16543 if(!isWasmInitialized) {
16544 throw new Error("initializeWasm() must be awaited first!");
16546 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
16547 return nativeResponseValue;
16549 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
16551 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
16552 if(!isWasmInitialized) {
16553 throw new Error("initializeWasm() must be awaited first!");
16555 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
16556 return nativeResponseValue;
16558 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
16560 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
16561 if(!isWasmInitialized) {
16562 throw new Error("initializeWasm() must be awaited first!");
16564 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
16565 return nativeResponseValue;
16567 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
16569 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
16570 if(!isWasmInitialized) {
16571 throw new Error("initializeWasm() must be awaited first!");
16573 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
16574 return nativeResponseValue;
16576 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
16578 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
16579 if(!isWasmInitialized) {
16580 throw new Error("initializeWasm() must be awaited first!");
16582 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
16583 // debug statements here
16585 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
16587 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16588 if(!isWasmInitialized) {
16589 throw new Error("initializeWasm() must be awaited first!");
16591 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
16592 return nativeResponseValue;
16594 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
16596 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
16597 if(!isWasmInitialized) {
16598 throw new Error("initializeWasm() must be awaited first!");
16600 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
16601 return nativeResponseValue;
16603 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
16605 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
16606 if(!isWasmInitialized) {
16607 throw new Error("initializeWasm() must be awaited first!");
16609 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
16610 return nativeResponseValue;
16612 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16614 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
16615 if(!isWasmInitialized) {
16616 throw new Error("initializeWasm() must be awaited first!");
16618 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
16619 return nativeResponseValue;
16621 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
16623 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16624 if(!isWasmInitialized) {
16625 throw new Error("initializeWasm() must be awaited first!");
16627 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
16628 return nativeResponseValue;
16630 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
16632 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
16633 if(!isWasmInitialized) {
16634 throw new Error("initializeWasm() must be awaited first!");
16636 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
16637 // debug statements here
16639 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
16641 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16642 if(!isWasmInitialized) {
16643 throw new Error("initializeWasm() must be awaited first!");
16645 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
16646 return nativeResponseValue;
16648 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
16650 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16651 if(!isWasmInitialized) {
16652 throw new Error("initializeWasm() must be awaited first!");
16654 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
16655 return nativeResponseValue;
16657 // uint64_t C2Tuple_OutPointCVec_u8ZZ_clone_ptr(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR arg);
16659 export function C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg: bigint): bigint {
16660 if(!isWasmInitialized) {
16661 throw new Error("initializeWasm() must be awaited first!");
16663 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg);
16664 return nativeResponseValue;
16666 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_clone(const struct LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR orig);
16668 export function C2Tuple_OutPointCVec_u8ZZ_clone(orig: bigint): bigint {
16669 if(!isWasmInitialized) {
16670 throw new Error("initializeWasm() must be awaited first!");
16672 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone(orig);
16673 return nativeResponseValue;
16675 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
16677 export function C2Tuple_OutPointCVec_u8ZZ_new(a: bigint, b: number): bigint {
16678 if(!isWasmInitialized) {
16679 throw new Error("initializeWasm() must be awaited first!");
16681 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_new(a, b);
16682 return nativeResponseValue;
16684 // void C2Tuple_OutPointCVec_u8ZZ_free(struct LDKC2Tuple_OutPointCVec_u8ZZ _res);
16686 export function C2Tuple_OutPointCVec_u8ZZ_free(_res: bigint): void {
16687 if(!isWasmInitialized) {
16688 throw new Error("initializeWasm() must be awaited first!");
16690 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_free(_res);
16691 // debug statements here
16693 // uint64_t C2Tuple_u32CVec_u8ZZ_clone_ptr(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR arg);
16695 export function C2Tuple_u32CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
16696 if(!isWasmInitialized) {
16697 throw new Error("initializeWasm() must be awaited first!");
16699 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone_ptr(arg);
16700 return nativeResponseValue;
16702 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_clone(const struct LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR orig);
16704 export function C2Tuple_u32CVec_u8ZZ_clone(orig: bigint): bigint {
16705 if(!isWasmInitialized) {
16706 throw new Error("initializeWasm() must be awaited first!");
16708 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone(orig);
16709 return nativeResponseValue;
16711 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_new(uint32_t a, struct LDKCVec_u8Z b);
16713 export function C2Tuple_u32CVec_u8ZZ_new(a: number, b: number): bigint {
16714 if(!isWasmInitialized) {
16715 throw new Error("initializeWasm() must be awaited first!");
16717 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_new(a, b);
16718 return nativeResponseValue;
16720 // void C2Tuple_u32CVec_u8ZZ_free(struct LDKC2Tuple_u32CVec_u8ZZ _res);
16722 export function C2Tuple_u32CVec_u8ZZ_free(_res: bigint): void {
16723 if(!isWasmInitialized) {
16724 throw new Error("initializeWasm() must be awaited first!");
16726 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_free(_res);
16727 // debug statements here
16729 // void CVec_C2Tuple_u32CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u32CVec_u8ZZZ _res);
16731 export function CVec_C2Tuple_u32CVec_u8ZZZ_free(_res: number): void {
16732 if(!isWasmInitialized) {
16733 throw new Error("initializeWasm() must be awaited first!");
16735 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32CVec_u8ZZZ_free(_res);
16736 // debug statements here
16738 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR arg);
16740 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg: bigint): bigint {
16741 if(!isWasmInitialized) {
16742 throw new Error("initializeWasm() must be awaited first!");
16744 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg);
16745 return nativeResponseValue;
16747 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR orig);
16749 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig: bigint): bigint {
16750 if(!isWasmInitialized) {
16751 throw new Error("initializeWasm() must be awaited first!");
16753 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig);
16754 return nativeResponseValue;
16756 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32CVec_u8ZZZ b);
16758 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a: number, b: number): bigint {
16759 if(!isWasmInitialized) {
16760 throw new Error("initializeWasm() must be awaited first!");
16762 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a, b);
16763 return nativeResponseValue;
16765 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ _res);
16767 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res: bigint): void {
16768 if(!isWasmInitialized) {
16769 throw new Error("initializeWasm() must be awaited first!");
16771 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res);
16772 // debug statements here
16774 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ _res);
16776 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res: number): void {
16777 if(!isWasmInitialized) {
16778 throw new Error("initializeWasm() must be awaited first!");
16780 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res);
16781 // debug statements here
16783 // void CVec_CommitmentTransactionZ_free(struct LDKCVec_CommitmentTransactionZ _res);
16785 export function CVec_CommitmentTransactionZ_free(_res: number): void {
16786 if(!isWasmInitialized) {
16787 throw new Error("initializeWasm() must be awaited first!");
16789 const nativeResponseValue = wasm.TS_CVec_CommitmentTransactionZ_free(_res);
16790 // debug statements here
16792 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
16794 export function CVec_TransactionZ_free(_res: number): void {
16795 if(!isWasmInitialized) {
16796 throw new Error("initializeWasm() must be awaited first!");
16798 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
16799 // debug statements here
16801 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
16803 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
16804 if(!isWasmInitialized) {
16805 throw new Error("initializeWasm() must be awaited first!");
16807 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
16808 return nativeResponseValue;
16810 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
16812 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
16813 if(!isWasmInitialized) {
16814 throw new Error("initializeWasm() must be awaited first!");
16816 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
16817 return nativeResponseValue;
16819 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
16821 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
16822 if(!isWasmInitialized) {
16823 throw new Error("initializeWasm() must be awaited first!");
16825 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
16826 return nativeResponseValue;
16828 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
16830 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
16831 if(!isWasmInitialized) {
16832 throw new Error("initializeWasm() must be awaited first!");
16834 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
16835 // debug statements here
16837 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
16839 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
16840 if(!isWasmInitialized) {
16841 throw new Error("initializeWasm() must be awaited first!");
16843 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
16844 // debug statements here
16846 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
16848 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
16849 if(!isWasmInitialized) {
16850 throw new Error("initializeWasm() must be awaited first!");
16852 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
16853 return nativeResponseValue;
16855 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
16857 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
16858 if(!isWasmInitialized) {
16859 throw new Error("initializeWasm() must be awaited first!");
16861 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig);
16862 return nativeResponseValue;
16864 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
16866 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
16867 if(!isWasmInitialized) {
16868 throw new Error("initializeWasm() must be awaited first!");
16870 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a, b);
16871 return nativeResponseValue;
16873 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ _res);
16875 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
16876 if(!isWasmInitialized) {
16877 throw new Error("initializeWasm() must be awaited first!");
16879 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res);
16880 // debug statements here
16882 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ _res);
16884 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
16885 if(!isWasmInitialized) {
16886 throw new Error("initializeWasm() must be awaited first!");
16888 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res);
16889 // debug statements here
16891 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
16893 export function CVec_BalanceZ_free(_res: number): void {
16894 if(!isWasmInitialized) {
16895 throw new Error("initializeWasm() must be awaited first!");
16897 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
16898 // debug statements here
16900 // uint64_t C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR arg);
16902 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg: bigint): bigint {
16903 if(!isWasmInitialized) {
16904 throw new Error("initializeWasm() must be awaited first!");
16906 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg);
16907 return nativeResponseValue;
16909 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR orig);
16911 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig: bigint): bigint {
16912 if(!isWasmInitialized) {
16913 throw new Error("initializeWasm() must be awaited first!");
16915 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig);
16916 return nativeResponseValue;
16918 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
16920 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a: number, b: bigint): bigint {
16921 if(!isWasmInitialized) {
16922 throw new Error("initializeWasm() must be awaited first!");
16924 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a, b);
16925 return nativeResponseValue;
16927 // void C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ _res);
16929 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res: bigint): void {
16930 if(!isWasmInitialized) {
16931 throw new Error("initializeWasm() must be awaited first!");
16933 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res);
16934 // debug statements here
16936 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
16938 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
16939 if(!isWasmInitialized) {
16940 throw new Error("initializeWasm() must be awaited first!");
16942 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o);
16943 return nativeResponseValue;
16945 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
16947 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
16948 if(!isWasmInitialized) {
16949 throw new Error("initializeWasm() must be awaited first!");
16951 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e);
16952 return nativeResponseValue;
16954 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
16956 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
16957 if(!isWasmInitialized) {
16958 throw new Error("initializeWasm() must be awaited first!");
16960 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o);
16961 return nativeResponseValue;
16963 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ _res);
16965 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
16966 if(!isWasmInitialized) {
16967 throw new Error("initializeWasm() must be awaited first!");
16969 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res);
16970 // debug statements here
16972 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
16974 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16975 if(!isWasmInitialized) {
16976 throw new Error("initializeWasm() must be awaited first!");
16978 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg);
16979 return nativeResponseValue;
16981 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
16983 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
16984 if(!isWasmInitialized) {
16985 throw new Error("initializeWasm() must be awaited first!");
16987 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig);
16988 return nativeResponseValue;
16990 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
16992 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
16993 if(!isWasmInitialized) {
16994 throw new Error("initializeWasm() must be awaited first!");
16996 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
16997 return nativeResponseValue;
16999 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
17001 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
17002 if(!isWasmInitialized) {
17003 throw new Error("initializeWasm() must be awaited first!");
17005 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
17006 return nativeResponseValue;
17008 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
17010 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
17011 if(!isWasmInitialized) {
17012 throw new Error("initializeWasm() must be awaited first!");
17014 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
17015 return nativeResponseValue;
17017 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
17019 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
17020 if(!isWasmInitialized) {
17021 throw new Error("initializeWasm() must be awaited first!");
17023 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
17024 // debug statements here
17026 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
17028 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
17029 if(!isWasmInitialized) {
17030 throw new Error("initializeWasm() must be awaited first!");
17032 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
17033 // debug statements here
17035 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_some(struct LDKOffersMessage o);
17037 export function COption_OffersMessageZ_some(o: bigint): bigint {
17038 if(!isWasmInitialized) {
17039 throw new Error("initializeWasm() must be awaited first!");
17041 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_some(o);
17042 return nativeResponseValue;
17044 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_none(void);
17046 export function COption_OffersMessageZ_none(): bigint {
17047 if(!isWasmInitialized) {
17048 throw new Error("initializeWasm() must be awaited first!");
17050 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_none();
17051 return nativeResponseValue;
17053 // void COption_OffersMessageZ_free(struct LDKCOption_OffersMessageZ _res);
17055 export function COption_OffersMessageZ_free(_res: bigint): void {
17056 if(!isWasmInitialized) {
17057 throw new Error("initializeWasm() must be awaited first!");
17059 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_free(_res);
17060 // debug statements here
17062 // uint64_t COption_OffersMessageZ_clone_ptr(LDKCOption_OffersMessageZ *NONNULL_PTR arg);
17064 export function COption_OffersMessageZ_clone_ptr(arg: bigint): bigint {
17065 if(!isWasmInitialized) {
17066 throw new Error("initializeWasm() must be awaited first!");
17068 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone_ptr(arg);
17069 return nativeResponseValue;
17071 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_clone(const struct LDKCOption_OffersMessageZ *NONNULL_PTR orig);
17073 export function COption_OffersMessageZ_clone(orig: bigint): bigint {
17074 if(!isWasmInitialized) {
17075 throw new Error("initializeWasm() must be awaited first!");
17077 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone(orig);
17078 return nativeResponseValue;
17080 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_some(struct LDKCustomOnionMessageContents o);
17082 export function COption_CustomOnionMessageContentsZ_some(o: bigint): bigint {
17083 if(!isWasmInitialized) {
17084 throw new Error("initializeWasm() must be awaited first!");
17086 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_some(o);
17087 return nativeResponseValue;
17089 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_none(void);
17091 export function COption_CustomOnionMessageContentsZ_none(): bigint {
17092 if(!isWasmInitialized) {
17093 throw new Error("initializeWasm() must be awaited first!");
17095 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_none();
17096 return nativeResponseValue;
17098 // void COption_CustomOnionMessageContentsZ_free(struct LDKCOption_CustomOnionMessageContentsZ _res);
17100 export function COption_CustomOnionMessageContentsZ_free(_res: bigint): void {
17101 if(!isWasmInitialized) {
17102 throw new Error("initializeWasm() must be awaited first!");
17104 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_free(_res);
17105 // debug statements here
17107 // uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg);
17109 export function COption_CustomOnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
17110 if(!isWasmInitialized) {
17111 throw new Error("initializeWasm() must be awaited first!");
17113 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone_ptr(arg);
17114 return nativeResponseValue;
17116 // struct LDKCOption_CustomOnionMessageContentsZ COption_CustomOnionMessageContentsZ_clone(const struct LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR orig);
17118 export function COption_CustomOnionMessageContentsZ_clone(orig: bigint): bigint {
17119 if(!isWasmInitialized) {
17120 throw new Error("initializeWasm() must be awaited first!");
17122 const nativeResponseValue = wasm.TS_COption_CustomOnionMessageContentsZ_clone(orig);
17123 return nativeResponseValue;
17125 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_CustomOnionMessageContentsZ o);
17127 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
17128 if(!isWasmInitialized) {
17129 throw new Error("initializeWasm() must be awaited first!");
17131 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o);
17132 return nativeResponseValue;
17134 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
17136 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
17137 if(!isWasmInitialized) {
17138 throw new Error("initializeWasm() must be awaited first!");
17140 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e);
17141 return nativeResponseValue;
17143 // bool CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
17145 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
17146 if(!isWasmInitialized) {
17147 throw new Error("initializeWasm() must be awaited first!");
17149 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o);
17150 return nativeResponseValue;
17152 // void CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res);
17154 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
17155 if(!isWasmInitialized) {
17156 throw new Error("initializeWasm() must be awaited first!");
17158 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res);
17159 // debug statements here
17161 // uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
17163 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17164 if(!isWasmInitialized) {
17165 throw new Error("initializeWasm() must be awaited first!");
17167 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
17168 return nativeResponseValue;
17170 // struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
17172 export function CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
17173 if(!isWasmInitialized) {
17174 throw new Error("initializeWasm() must be awaited first!");
17176 const nativeResponseValue = wasm.TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig);
17177 return nativeResponseValue;
17179 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
17181 export function COption_TypeZ_some(o: bigint): bigint {
17182 if(!isWasmInitialized) {
17183 throw new Error("initializeWasm() must be awaited first!");
17185 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
17186 return nativeResponseValue;
17188 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
17190 export function COption_TypeZ_none(): bigint {
17191 if(!isWasmInitialized) {
17192 throw new Error("initializeWasm() must be awaited first!");
17194 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
17195 return nativeResponseValue;
17197 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
17199 export function COption_TypeZ_free(_res: bigint): void {
17200 if(!isWasmInitialized) {
17201 throw new Error("initializeWasm() must be awaited first!");
17203 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
17204 // debug statements here
17206 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
17208 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
17209 if(!isWasmInitialized) {
17210 throw new Error("initializeWasm() must be awaited first!");
17212 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
17213 return nativeResponseValue;
17215 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
17217 export function COption_TypeZ_clone(orig: bigint): bigint {
17218 if(!isWasmInitialized) {
17219 throw new Error("initializeWasm() must be awaited first!");
17221 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
17222 return nativeResponseValue;
17224 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
17226 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
17227 if(!isWasmInitialized) {
17228 throw new Error("initializeWasm() must be awaited first!");
17230 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
17231 return nativeResponseValue;
17233 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
17235 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
17236 if(!isWasmInitialized) {
17237 throw new Error("initializeWasm() must be awaited first!");
17239 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
17240 return nativeResponseValue;
17242 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
17244 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
17245 if(!isWasmInitialized) {
17246 throw new Error("initializeWasm() must be awaited first!");
17248 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
17249 return nativeResponseValue;
17251 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
17253 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
17254 if(!isWasmInitialized) {
17255 throw new Error("initializeWasm() must be awaited first!");
17257 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
17258 // debug statements here
17260 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
17262 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17263 if(!isWasmInitialized) {
17264 throw new Error("initializeWasm() must be awaited first!");
17266 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
17267 return nativeResponseValue;
17269 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
17271 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
17272 if(!isWasmInitialized) {
17273 throw new Error("initializeWasm() must be awaited first!");
17275 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
17276 return nativeResponseValue;
17278 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_some(struct LDKSocketAddress o);
17280 export function COption_SocketAddressZ_some(o: bigint): bigint {
17281 if(!isWasmInitialized) {
17282 throw new Error("initializeWasm() must be awaited first!");
17284 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_some(o);
17285 return nativeResponseValue;
17287 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_none(void);
17289 export function COption_SocketAddressZ_none(): bigint {
17290 if(!isWasmInitialized) {
17291 throw new Error("initializeWasm() must be awaited first!");
17293 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_none();
17294 return nativeResponseValue;
17296 // void COption_SocketAddressZ_free(struct LDKCOption_SocketAddressZ _res);
17298 export function COption_SocketAddressZ_free(_res: bigint): void {
17299 if(!isWasmInitialized) {
17300 throw new Error("initializeWasm() must be awaited first!");
17302 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_free(_res);
17303 // debug statements here
17305 // uint64_t COption_SocketAddressZ_clone_ptr(LDKCOption_SocketAddressZ *NONNULL_PTR arg);
17307 export function COption_SocketAddressZ_clone_ptr(arg: bigint): bigint {
17308 if(!isWasmInitialized) {
17309 throw new Error("initializeWasm() must be awaited first!");
17311 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone_ptr(arg);
17312 return nativeResponseValue;
17314 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_clone(const struct LDKCOption_SocketAddressZ *NONNULL_PTR orig);
17316 export function COption_SocketAddressZ_clone(orig: bigint): bigint {
17317 if(!isWasmInitialized) {
17318 throw new Error("initializeWasm() must be awaited first!");
17320 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone(orig);
17321 return nativeResponseValue;
17323 // uint64_t C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR arg);
17325 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
17326 if(!isWasmInitialized) {
17327 throw new Error("initializeWasm() must be awaited first!");
17329 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg);
17330 return nativeResponseValue;
17332 // struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR orig);
17334 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig: bigint): bigint {
17335 if(!isWasmInitialized) {
17336 throw new Error("initializeWasm() must be awaited first!");
17338 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig);
17339 return nativeResponseValue;
17341 // struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ C2Tuple_PublicKeyCOption_SocketAddressZZ_new(struct LDKPublicKey a, struct LDKCOption_SocketAddressZ b);
17343 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a: number, b: bigint): bigint {
17344 if(!isWasmInitialized) {
17345 throw new Error("initializeWasm() must be awaited first!");
17347 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a, b);
17348 return nativeResponseValue;
17350 // void C2Tuple_PublicKeyCOption_SocketAddressZZ_free(struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ _res);
17352 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res: bigint): void {
17353 if(!isWasmInitialized) {
17354 throw new Error("initializeWasm() must be awaited first!");
17356 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res);
17357 // debug statements here
17359 // void CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ _res);
17361 export function CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res: number): void {
17362 if(!isWasmInitialized) {
17363 throw new Error("initializeWasm() must be awaited first!");
17365 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res);
17366 // debug statements here
17368 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
17370 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
17371 if(!isWasmInitialized) {
17372 throw new Error("initializeWasm() must be awaited first!");
17374 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
17375 return nativeResponseValue;
17377 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
17379 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
17380 if(!isWasmInitialized) {
17381 throw new Error("initializeWasm() must be awaited first!");
17383 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
17384 return nativeResponseValue;
17386 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
17388 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
17389 if(!isWasmInitialized) {
17390 throw new Error("initializeWasm() must be awaited first!");
17392 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
17393 return nativeResponseValue;
17395 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
17397 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
17398 if(!isWasmInitialized) {
17399 throw new Error("initializeWasm() must be awaited first!");
17401 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
17402 // debug statements here
17404 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
17406 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
17407 if(!isWasmInitialized) {
17408 throw new Error("initializeWasm() must be awaited first!");
17410 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
17411 return nativeResponseValue;
17413 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
17415 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
17416 if(!isWasmInitialized) {
17417 throw new Error("initializeWasm() must be awaited first!");
17419 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
17420 return nativeResponseValue;
17422 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
17424 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
17425 if(!isWasmInitialized) {
17426 throw new Error("initializeWasm() must be awaited first!");
17428 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
17429 return nativeResponseValue;
17431 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
17433 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
17434 if(!isWasmInitialized) {
17435 throw new Error("initializeWasm() must be awaited first!");
17437 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
17438 return nativeResponseValue;
17440 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
17442 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
17443 if(!isWasmInitialized) {
17444 throw new Error("initializeWasm() must be awaited first!");
17446 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
17447 return nativeResponseValue;
17449 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
17451 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
17452 if(!isWasmInitialized) {
17453 throw new Error("initializeWasm() must be awaited first!");
17455 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
17456 // debug statements here
17458 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
17460 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
17461 if(!isWasmInitialized) {
17462 throw new Error("initializeWasm() must be awaited first!");
17464 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
17465 return nativeResponseValue;
17467 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
17469 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
17470 if(!isWasmInitialized) {
17471 throw new Error("initializeWasm() must be awaited first!");
17473 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
17474 return nativeResponseValue;
17476 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
17478 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
17479 if(!isWasmInitialized) {
17480 throw new Error("initializeWasm() must be awaited first!");
17482 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
17483 return nativeResponseValue;
17485 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
17487 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
17488 if(!isWasmInitialized) {
17489 throw new Error("initializeWasm() must be awaited first!");
17491 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
17492 return nativeResponseValue;
17494 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
17496 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
17497 if(!isWasmInitialized) {
17498 throw new Error("initializeWasm() must be awaited first!");
17500 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
17501 return nativeResponseValue;
17503 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
17505 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
17506 if(!isWasmInitialized) {
17507 throw new Error("initializeWasm() must be awaited first!");
17509 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
17510 // debug statements here
17512 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
17514 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
17515 if(!isWasmInitialized) {
17516 throw new Error("initializeWasm() must be awaited first!");
17518 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
17519 return nativeResponseValue;
17521 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
17523 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
17524 if(!isWasmInitialized) {
17525 throw new Error("initializeWasm() must be awaited first!");
17527 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
17528 return nativeResponseValue;
17530 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
17532 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
17533 if(!isWasmInitialized) {
17534 throw new Error("initializeWasm() must be awaited first!");
17536 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
17537 return nativeResponseValue;
17539 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
17541 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
17542 if(!isWasmInitialized) {
17543 throw new Error("initializeWasm() must be awaited first!");
17545 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
17546 return nativeResponseValue;
17548 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
17550 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
17551 if(!isWasmInitialized) {
17552 throw new Error("initializeWasm() must be awaited first!");
17554 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
17555 return nativeResponseValue;
17557 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
17559 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
17560 if(!isWasmInitialized) {
17561 throw new Error("initializeWasm() must be awaited first!");
17563 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
17564 // debug statements here
17566 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_ok(struct LDKCVec_u8Z o);
17568 export function CResult_CVec_u8ZIOErrorZ_ok(o: number): bigint {
17569 if(!isWasmInitialized) {
17570 throw new Error("initializeWasm() must be awaited first!");
17572 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_ok(o);
17573 return nativeResponseValue;
17575 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_err(enum LDKIOError e);
17577 export function CResult_CVec_u8ZIOErrorZ_err(e: IOError): bigint {
17578 if(!isWasmInitialized) {
17579 throw new Error("initializeWasm() must be awaited first!");
17581 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_err(e);
17582 return nativeResponseValue;
17584 // bool CResult_CVec_u8ZIOErrorZ_is_ok(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR o);
17586 export function CResult_CVec_u8ZIOErrorZ_is_ok(o: bigint): boolean {
17587 if(!isWasmInitialized) {
17588 throw new Error("initializeWasm() must be awaited first!");
17590 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_is_ok(o);
17591 return nativeResponseValue;
17593 // void CResult_CVec_u8ZIOErrorZ_free(struct LDKCResult_CVec_u8ZIOErrorZ _res);
17595 export function CResult_CVec_u8ZIOErrorZ_free(_res: bigint): void {
17596 if(!isWasmInitialized) {
17597 throw new Error("initializeWasm() must be awaited first!");
17599 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_free(_res);
17600 // debug statements here
17602 // uint64_t CResult_CVec_u8ZIOErrorZ_clone_ptr(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR arg);
17604 export function CResult_CVec_u8ZIOErrorZ_clone_ptr(arg: bigint): bigint {
17605 if(!isWasmInitialized) {
17606 throw new Error("initializeWasm() must be awaited first!");
17608 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone_ptr(arg);
17609 return nativeResponseValue;
17611 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_clone(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR orig);
17613 export function CResult_CVec_u8ZIOErrorZ_clone(orig: bigint): bigint {
17614 if(!isWasmInitialized) {
17615 throw new Error("initializeWasm() must be awaited first!");
17617 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone(orig);
17618 return nativeResponseValue;
17620 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_ok(void);
17622 export function CResult_NoneIOErrorZ_ok(): bigint {
17623 if(!isWasmInitialized) {
17624 throw new Error("initializeWasm() must be awaited first!");
17626 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_ok();
17627 return nativeResponseValue;
17629 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_err(enum LDKIOError e);
17631 export function CResult_NoneIOErrorZ_err(e: IOError): bigint {
17632 if(!isWasmInitialized) {
17633 throw new Error("initializeWasm() must be awaited first!");
17635 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_err(e);
17636 return nativeResponseValue;
17638 // bool CResult_NoneIOErrorZ_is_ok(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR o);
17640 export function CResult_NoneIOErrorZ_is_ok(o: bigint): boolean {
17641 if(!isWasmInitialized) {
17642 throw new Error("initializeWasm() must be awaited first!");
17644 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_is_ok(o);
17645 return nativeResponseValue;
17647 // void CResult_NoneIOErrorZ_free(struct LDKCResult_NoneIOErrorZ _res);
17649 export function CResult_NoneIOErrorZ_free(_res: bigint): void {
17650 if(!isWasmInitialized) {
17651 throw new Error("initializeWasm() must be awaited first!");
17653 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_free(_res);
17654 // debug statements here
17656 // uint64_t CResult_NoneIOErrorZ_clone_ptr(LDKCResult_NoneIOErrorZ *NONNULL_PTR arg);
17658 export function CResult_NoneIOErrorZ_clone_ptr(arg: bigint): bigint {
17659 if(!isWasmInitialized) {
17660 throw new Error("initializeWasm() must be awaited first!");
17662 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone_ptr(arg);
17663 return nativeResponseValue;
17665 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_clone(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR orig);
17667 export function CResult_NoneIOErrorZ_clone(orig: bigint): bigint {
17668 if(!isWasmInitialized) {
17669 throw new Error("initializeWasm() must be awaited first!");
17671 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone(orig);
17672 return nativeResponseValue;
17674 // void CVec_StrZ_free(struct LDKCVec_StrZ _res);
17676 export function CVec_StrZ_free(_res: number): void {
17677 if(!isWasmInitialized) {
17678 throw new Error("initializeWasm() must be awaited first!");
17680 const nativeResponseValue = wasm.TS_CVec_StrZ_free(_res);
17681 // debug statements here
17683 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_ok(struct LDKCVec_StrZ o);
17685 export function CResult_CVec_StrZIOErrorZ_ok(o: number): bigint {
17686 if(!isWasmInitialized) {
17687 throw new Error("initializeWasm() must be awaited first!");
17689 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_ok(o);
17690 return nativeResponseValue;
17692 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_err(enum LDKIOError e);
17694 export function CResult_CVec_StrZIOErrorZ_err(e: IOError): bigint {
17695 if(!isWasmInitialized) {
17696 throw new Error("initializeWasm() must be awaited first!");
17698 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_err(e);
17699 return nativeResponseValue;
17701 // bool CResult_CVec_StrZIOErrorZ_is_ok(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR o);
17703 export function CResult_CVec_StrZIOErrorZ_is_ok(o: bigint): boolean {
17704 if(!isWasmInitialized) {
17705 throw new Error("initializeWasm() must be awaited first!");
17707 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_is_ok(o);
17708 return nativeResponseValue;
17710 // void CResult_CVec_StrZIOErrorZ_free(struct LDKCResult_CVec_StrZIOErrorZ _res);
17712 export function CResult_CVec_StrZIOErrorZ_free(_res: bigint): void {
17713 if(!isWasmInitialized) {
17714 throw new Error("initializeWasm() must be awaited first!");
17716 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_free(_res);
17717 // debug statements here
17719 // uint64_t CResult_CVec_StrZIOErrorZ_clone_ptr(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR arg);
17721 export function CResult_CVec_StrZIOErrorZ_clone_ptr(arg: bigint): bigint {
17722 if(!isWasmInitialized) {
17723 throw new Error("initializeWasm() must be awaited first!");
17725 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone_ptr(arg);
17726 return nativeResponseValue;
17728 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_clone(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR orig);
17730 export function CResult_CVec_StrZIOErrorZ_clone(orig: bigint): bigint {
17731 if(!isWasmInitialized) {
17732 throw new Error("initializeWasm() must be awaited first!");
17734 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone(orig);
17735 return nativeResponseValue;
17737 // void CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ _res);
17739 export function CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res: number): void {
17740 if(!isWasmInitialized) {
17741 throw new Error("initializeWasm() must be awaited first!");
17743 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res);
17744 // debug statements here
17746 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ o);
17748 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o: number): bigint {
17749 if(!isWasmInitialized) {
17750 throw new Error("initializeWasm() must be awaited first!");
17752 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o);
17753 return nativeResponseValue;
17755 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(enum LDKIOError e);
17757 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e: IOError): bigint {
17758 if(!isWasmInitialized) {
17759 throw new Error("initializeWasm() must be awaited first!");
17761 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e);
17762 return nativeResponseValue;
17764 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR o);
17766 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o: bigint): boolean {
17767 if(!isWasmInitialized) {
17768 throw new Error("initializeWasm() must be awaited first!");
17770 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o);
17771 return nativeResponseValue;
17773 // void CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ _res);
17775 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res: bigint): void {
17776 if(!isWasmInitialized) {
17777 throw new Error("initializeWasm() must be awaited first!");
17779 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res);
17780 // debug statements here
17782 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR arg);
17784 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg: bigint): bigint {
17785 if(!isWasmInitialized) {
17786 throw new Error("initializeWasm() must be awaited first!");
17788 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg);
17789 return nativeResponseValue;
17791 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR orig);
17793 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig: bigint): bigint {
17794 if(!isWasmInitialized) {
17795 throw new Error("initializeWasm() must be awaited first!");
17797 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig);
17798 return nativeResponseValue;
17800 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
17802 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o: bigint): bigint {
17803 if(!isWasmInitialized) {
17804 throw new Error("initializeWasm() must be awaited first!");
17806 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o);
17807 return nativeResponseValue;
17809 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(enum LDKIOError e);
17811 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e: IOError): bigint {
17812 if(!isWasmInitialized) {
17813 throw new Error("initializeWasm() must be awaited first!");
17815 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e);
17816 return nativeResponseValue;
17818 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR o);
17820 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o: bigint): boolean {
17821 if(!isWasmInitialized) {
17822 throw new Error("initializeWasm() must be awaited first!");
17824 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o);
17825 return nativeResponseValue;
17827 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ _res);
17829 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res: bigint): void {
17830 if(!isWasmInitialized) {
17831 throw new Error("initializeWasm() must be awaited first!");
17833 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res);
17834 // debug statements here
17836 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR arg);
17838 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg: bigint): bigint {
17839 if(!isWasmInitialized) {
17840 throw new Error("initializeWasm() must be awaited first!");
17842 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg);
17843 return nativeResponseValue;
17845 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR orig);
17847 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig: bigint): bigint {
17848 if(!isWasmInitialized) {
17849 throw new Error("initializeWasm() must be awaited first!");
17851 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig);
17852 return nativeResponseValue;
17854 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_some(struct LDKSecretKey o);
17856 export function COption_SecretKeyZ_some(o: number): bigint {
17857 if(!isWasmInitialized) {
17858 throw new Error("initializeWasm() must be awaited first!");
17860 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_some(o);
17861 return nativeResponseValue;
17863 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_none(void);
17865 export function COption_SecretKeyZ_none(): bigint {
17866 if(!isWasmInitialized) {
17867 throw new Error("initializeWasm() must be awaited first!");
17869 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_none();
17870 return nativeResponseValue;
17872 // void COption_SecretKeyZ_free(struct LDKCOption_SecretKeyZ _res);
17874 export function COption_SecretKeyZ_free(_res: bigint): void {
17875 if(!isWasmInitialized) {
17876 throw new Error("initializeWasm() must be awaited first!");
17878 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_free(_res);
17879 // debug statements here
17881 // uint64_t COption_SecretKeyZ_clone_ptr(LDKCOption_SecretKeyZ *NONNULL_PTR arg);
17883 export function COption_SecretKeyZ_clone_ptr(arg: bigint): bigint {
17884 if(!isWasmInitialized) {
17885 throw new Error("initializeWasm() must be awaited first!");
17887 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone_ptr(arg);
17888 return nativeResponseValue;
17890 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_clone(const struct LDKCOption_SecretKeyZ *NONNULL_PTR orig);
17892 export function COption_SecretKeyZ_clone(orig: bigint): bigint {
17893 if(!isWasmInitialized) {
17894 throw new Error("initializeWasm() must be awaited first!");
17896 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone(orig);
17897 return nativeResponseValue;
17899 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_ok(struct LDKVerifiedInvoiceRequest o);
17901 export function CResult_VerifiedInvoiceRequestNoneZ_ok(o: bigint): bigint {
17902 if(!isWasmInitialized) {
17903 throw new Error("initializeWasm() must be awaited first!");
17905 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_ok(o);
17906 return nativeResponseValue;
17908 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_err(void);
17910 export function CResult_VerifiedInvoiceRequestNoneZ_err(): bigint {
17911 if(!isWasmInitialized) {
17912 throw new Error("initializeWasm() must be awaited first!");
17914 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_err();
17915 return nativeResponseValue;
17917 // bool CResult_VerifiedInvoiceRequestNoneZ_is_ok(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR o);
17919 export function CResult_VerifiedInvoiceRequestNoneZ_is_ok(o: bigint): boolean {
17920 if(!isWasmInitialized) {
17921 throw new Error("initializeWasm() must be awaited first!");
17923 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_is_ok(o);
17924 return nativeResponseValue;
17926 // void CResult_VerifiedInvoiceRequestNoneZ_free(struct LDKCResult_VerifiedInvoiceRequestNoneZ _res);
17928 export function CResult_VerifiedInvoiceRequestNoneZ_free(_res: bigint): void {
17929 if(!isWasmInitialized) {
17930 throw new Error("initializeWasm() must be awaited first!");
17932 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_free(_res);
17933 // debug statements here
17935 // uint64_t CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR arg);
17937 export function CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg: bigint): bigint {
17938 if(!isWasmInitialized) {
17939 throw new Error("initializeWasm() must be awaited first!");
17941 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg);
17942 return nativeResponseValue;
17944 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_clone(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR orig);
17946 export function CResult_VerifiedInvoiceRequestNoneZ_clone(orig: bigint): bigint {
17947 if(!isWasmInitialized) {
17948 throw new Error("initializeWasm() must be awaited first!");
17950 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone(orig);
17951 return nativeResponseValue;
17953 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
17955 export function COption_NoneZ_some(): COption_NoneZ {
17956 if(!isWasmInitialized) {
17957 throw new Error("initializeWasm() must be awaited first!");
17959 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
17960 return nativeResponseValue;
17962 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
17964 export function COption_NoneZ_none(): COption_NoneZ {
17965 if(!isWasmInitialized) {
17966 throw new Error("initializeWasm() must be awaited first!");
17968 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
17969 return nativeResponseValue;
17971 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
17973 export function COption_NoneZ_free(_res: COption_NoneZ): void {
17974 if(!isWasmInitialized) {
17975 throw new Error("initializeWasm() must be awaited first!");
17977 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
17978 // debug statements here
17980 // void CVec_WitnessZ_free(struct LDKCVec_WitnessZ _res);
17982 export function CVec_WitnessZ_free(_res: number): void {
17983 if(!isWasmInitialized) {
17984 throw new Error("initializeWasm() must be awaited first!");
17986 const nativeResponseValue = wasm.TS_CVec_WitnessZ_free(_res);
17987 // debug statements here
17989 // struct LDKCOption_i64Z COption_i64Z_some(int64_t o);
17991 export function COption_i64Z_some(o: bigint): bigint {
17992 if(!isWasmInitialized) {
17993 throw new Error("initializeWasm() must be awaited first!");
17995 const nativeResponseValue = wasm.TS_COption_i64Z_some(o);
17996 return nativeResponseValue;
17998 // struct LDKCOption_i64Z COption_i64Z_none(void);
18000 export function COption_i64Z_none(): bigint {
18001 if(!isWasmInitialized) {
18002 throw new Error("initializeWasm() must be awaited first!");
18004 const nativeResponseValue = wasm.TS_COption_i64Z_none();
18005 return nativeResponseValue;
18007 // void COption_i64Z_free(struct LDKCOption_i64Z _res);
18009 export function COption_i64Z_free(_res: bigint): void {
18010 if(!isWasmInitialized) {
18011 throw new Error("initializeWasm() must be awaited first!");
18013 const nativeResponseValue = wasm.TS_COption_i64Z_free(_res);
18014 // debug statements here
18016 // uint64_t COption_i64Z_clone_ptr(LDKCOption_i64Z *NONNULL_PTR arg);
18018 export function COption_i64Z_clone_ptr(arg: bigint): bigint {
18019 if(!isWasmInitialized) {
18020 throw new Error("initializeWasm() must be awaited first!");
18022 const nativeResponseValue = wasm.TS_COption_i64Z_clone_ptr(arg);
18023 return nativeResponseValue;
18025 // struct LDKCOption_i64Z COption_i64Z_clone(const struct LDKCOption_i64Z *NONNULL_PTR orig);
18027 export function COption_i64Z_clone(orig: bigint): bigint {
18028 if(!isWasmInitialized) {
18029 throw new Error("initializeWasm() must be awaited first!");
18031 const nativeResponseValue = wasm.TS_COption_i64Z_clone(orig);
18032 return nativeResponseValue;
18034 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_ok(struct LDKSocketAddress o);
18036 export function CResult_SocketAddressDecodeErrorZ_ok(o: bigint): bigint {
18037 if(!isWasmInitialized) {
18038 throw new Error("initializeWasm() must be awaited first!");
18040 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_ok(o);
18041 return nativeResponseValue;
18043 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_err(struct LDKDecodeError e);
18045 export function CResult_SocketAddressDecodeErrorZ_err(e: bigint): bigint {
18046 if(!isWasmInitialized) {
18047 throw new Error("initializeWasm() must be awaited first!");
18049 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_err(e);
18050 return nativeResponseValue;
18052 // bool CResult_SocketAddressDecodeErrorZ_is_ok(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR o);
18054 export function CResult_SocketAddressDecodeErrorZ_is_ok(o: bigint): boolean {
18055 if(!isWasmInitialized) {
18056 throw new Error("initializeWasm() must be awaited first!");
18058 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_is_ok(o);
18059 return nativeResponseValue;
18061 // void CResult_SocketAddressDecodeErrorZ_free(struct LDKCResult_SocketAddressDecodeErrorZ _res);
18063 export function CResult_SocketAddressDecodeErrorZ_free(_res: bigint): void {
18064 if(!isWasmInitialized) {
18065 throw new Error("initializeWasm() must be awaited first!");
18067 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_free(_res);
18068 // debug statements here
18070 // uint64_t CResult_SocketAddressDecodeErrorZ_clone_ptr(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR arg);
18072 export function CResult_SocketAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18073 if(!isWasmInitialized) {
18074 throw new Error("initializeWasm() must be awaited first!");
18076 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone_ptr(arg);
18077 return nativeResponseValue;
18079 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_clone(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR orig);
18081 export function CResult_SocketAddressDecodeErrorZ_clone(orig: bigint): bigint {
18082 if(!isWasmInitialized) {
18083 throw new Error("initializeWasm() must be awaited first!");
18085 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone(orig);
18086 return nativeResponseValue;
18088 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_ok(struct LDKSocketAddress o);
18090 export function CResult_SocketAddressSocketAddressParseErrorZ_ok(o: bigint): bigint {
18091 if(!isWasmInitialized) {
18092 throw new Error("initializeWasm() must be awaited first!");
18094 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_ok(o);
18095 return nativeResponseValue;
18097 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_err(enum LDKSocketAddressParseError e);
18099 export function CResult_SocketAddressSocketAddressParseErrorZ_err(e: SocketAddressParseError): bigint {
18100 if(!isWasmInitialized) {
18101 throw new Error("initializeWasm() must be awaited first!");
18103 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_err(e);
18104 return nativeResponseValue;
18106 // bool CResult_SocketAddressSocketAddressParseErrorZ_is_ok(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR o);
18108 export function CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o: bigint): boolean {
18109 if(!isWasmInitialized) {
18110 throw new Error("initializeWasm() must be awaited first!");
18112 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o);
18113 return nativeResponseValue;
18115 // void CResult_SocketAddressSocketAddressParseErrorZ_free(struct LDKCResult_SocketAddressSocketAddressParseErrorZ _res);
18117 export function CResult_SocketAddressSocketAddressParseErrorZ_free(_res: bigint): void {
18118 if(!isWasmInitialized) {
18119 throw new Error("initializeWasm() must be awaited first!");
18121 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_free(_res);
18122 // debug statements here
18124 // uint64_t CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR arg);
18126 export function CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg: bigint): bigint {
18127 if(!isWasmInitialized) {
18128 throw new Error("initializeWasm() must be awaited first!");
18130 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg);
18131 return nativeResponseValue;
18133 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_clone(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR orig);
18135 export function CResult_SocketAddressSocketAddressParseErrorZ_clone(orig: bigint): bigint {
18136 if(!isWasmInitialized) {
18137 throw new Error("initializeWasm() must be awaited first!");
18139 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone(orig);
18140 return nativeResponseValue;
18142 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
18144 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
18145 if(!isWasmInitialized) {
18146 throw new Error("initializeWasm() must be awaited first!");
18148 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
18149 // debug statements here
18151 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
18153 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
18154 if(!isWasmInitialized) {
18155 throw new Error("initializeWasm() must be awaited first!");
18157 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
18158 // debug statements here
18160 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
18162 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
18163 if(!isWasmInitialized) {
18164 throw new Error("initializeWasm() must be awaited first!");
18166 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
18167 // debug statements here
18169 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
18171 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
18172 if(!isWasmInitialized) {
18173 throw new Error("initializeWasm() must be awaited first!");
18175 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
18176 // debug statements here
18178 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
18180 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
18181 if(!isWasmInitialized) {
18182 throw new Error("initializeWasm() must be awaited first!");
18184 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
18185 return nativeResponseValue;
18187 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
18189 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
18190 if(!isWasmInitialized) {
18191 throw new Error("initializeWasm() must be awaited first!");
18193 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
18194 return nativeResponseValue;
18196 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
18198 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
18199 if(!isWasmInitialized) {
18200 throw new Error("initializeWasm() must be awaited first!");
18202 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
18203 return nativeResponseValue;
18205 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
18207 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
18208 if(!isWasmInitialized) {
18209 throw new Error("initializeWasm() must be awaited first!");
18211 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
18212 // debug statements here
18214 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
18216 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18217 if(!isWasmInitialized) {
18218 throw new Error("initializeWasm() must be awaited first!");
18220 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
18221 return nativeResponseValue;
18223 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
18225 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
18226 if(!isWasmInitialized) {
18227 throw new Error("initializeWasm() must be awaited first!");
18229 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
18230 return nativeResponseValue;
18232 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_ok(struct LDKAcceptChannelV2 o);
18234 export function CResult_AcceptChannelV2DecodeErrorZ_ok(o: bigint): bigint {
18235 if(!isWasmInitialized) {
18236 throw new Error("initializeWasm() must be awaited first!");
18238 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_ok(o);
18239 return nativeResponseValue;
18241 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
18243 export function CResult_AcceptChannelV2DecodeErrorZ_err(e: bigint): bigint {
18244 if(!isWasmInitialized) {
18245 throw new Error("initializeWasm() must be awaited first!");
18247 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_err(e);
18248 return nativeResponseValue;
18250 // bool CResult_AcceptChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR o);
18252 export function CResult_AcceptChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
18253 if(!isWasmInitialized) {
18254 throw new Error("initializeWasm() must be awaited first!");
18256 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok(o);
18257 return nativeResponseValue;
18259 // void CResult_AcceptChannelV2DecodeErrorZ_free(struct LDKCResult_AcceptChannelV2DecodeErrorZ _res);
18261 export function CResult_AcceptChannelV2DecodeErrorZ_free(_res: bigint): void {
18262 if(!isWasmInitialized) {
18263 throw new Error("initializeWasm() must be awaited first!");
18265 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_free(_res);
18266 // debug statements here
18268 // uint64_t CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR arg);
18270 export function CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
18271 if(!isWasmInitialized) {
18272 throw new Error("initializeWasm() must be awaited first!");
18274 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg);
18275 return nativeResponseValue;
18277 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_clone(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR orig);
18279 export function CResult_AcceptChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
18280 if(!isWasmInitialized) {
18281 throw new Error("initializeWasm() must be awaited first!");
18283 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone(orig);
18284 return nativeResponseValue;
18286 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_ok(struct LDKTxAddInput o);
18288 export function CResult_TxAddInputDecodeErrorZ_ok(o: bigint): bigint {
18289 if(!isWasmInitialized) {
18290 throw new Error("initializeWasm() must be awaited first!");
18292 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_ok(o);
18293 return nativeResponseValue;
18295 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_err(struct LDKDecodeError e);
18297 export function CResult_TxAddInputDecodeErrorZ_err(e: bigint): bigint {
18298 if(!isWasmInitialized) {
18299 throw new Error("initializeWasm() must be awaited first!");
18301 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_err(e);
18302 return nativeResponseValue;
18304 // bool CResult_TxAddInputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR o);
18306 export function CResult_TxAddInputDecodeErrorZ_is_ok(o: bigint): boolean {
18307 if(!isWasmInitialized) {
18308 throw new Error("initializeWasm() must be awaited first!");
18310 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_is_ok(o);
18311 return nativeResponseValue;
18313 // void CResult_TxAddInputDecodeErrorZ_free(struct LDKCResult_TxAddInputDecodeErrorZ _res);
18315 export function CResult_TxAddInputDecodeErrorZ_free(_res: bigint): void {
18316 if(!isWasmInitialized) {
18317 throw new Error("initializeWasm() must be awaited first!");
18319 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_free(_res);
18320 // debug statements here
18322 // uint64_t CResult_TxAddInputDecodeErrorZ_clone_ptr(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR arg);
18324 export function CResult_TxAddInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18325 if(!isWasmInitialized) {
18326 throw new Error("initializeWasm() must be awaited first!");
18328 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone_ptr(arg);
18329 return nativeResponseValue;
18331 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_clone(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR orig);
18333 export function CResult_TxAddInputDecodeErrorZ_clone(orig: bigint): bigint {
18334 if(!isWasmInitialized) {
18335 throw new Error("initializeWasm() must be awaited first!");
18337 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone(orig);
18338 return nativeResponseValue;
18340 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_ok(struct LDKTxAddOutput o);
18342 export function CResult_TxAddOutputDecodeErrorZ_ok(o: bigint): bigint {
18343 if(!isWasmInitialized) {
18344 throw new Error("initializeWasm() must be awaited first!");
18346 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_ok(o);
18347 return nativeResponseValue;
18349 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_err(struct LDKDecodeError e);
18351 export function CResult_TxAddOutputDecodeErrorZ_err(e: bigint): bigint {
18352 if(!isWasmInitialized) {
18353 throw new Error("initializeWasm() must be awaited first!");
18355 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_err(e);
18356 return nativeResponseValue;
18358 // bool CResult_TxAddOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR o);
18360 export function CResult_TxAddOutputDecodeErrorZ_is_ok(o: bigint): boolean {
18361 if(!isWasmInitialized) {
18362 throw new Error("initializeWasm() must be awaited first!");
18364 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_is_ok(o);
18365 return nativeResponseValue;
18367 // void CResult_TxAddOutputDecodeErrorZ_free(struct LDKCResult_TxAddOutputDecodeErrorZ _res);
18369 export function CResult_TxAddOutputDecodeErrorZ_free(_res: bigint): void {
18370 if(!isWasmInitialized) {
18371 throw new Error("initializeWasm() must be awaited first!");
18373 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_free(_res);
18374 // debug statements here
18376 // uint64_t CResult_TxAddOutputDecodeErrorZ_clone_ptr(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR arg);
18378 export function CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18379 if(!isWasmInitialized) {
18380 throw new Error("initializeWasm() must be awaited first!");
18382 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg);
18383 return nativeResponseValue;
18385 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_clone(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR orig);
18387 export function CResult_TxAddOutputDecodeErrorZ_clone(orig: bigint): bigint {
18388 if(!isWasmInitialized) {
18389 throw new Error("initializeWasm() must be awaited first!");
18391 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone(orig);
18392 return nativeResponseValue;
18394 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_ok(struct LDKTxRemoveInput o);
18396 export function CResult_TxRemoveInputDecodeErrorZ_ok(o: bigint): bigint {
18397 if(!isWasmInitialized) {
18398 throw new Error("initializeWasm() must be awaited first!");
18400 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_ok(o);
18401 return nativeResponseValue;
18403 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_err(struct LDKDecodeError e);
18405 export function CResult_TxRemoveInputDecodeErrorZ_err(e: bigint): bigint {
18406 if(!isWasmInitialized) {
18407 throw new Error("initializeWasm() must be awaited first!");
18409 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_err(e);
18410 return nativeResponseValue;
18412 // bool CResult_TxRemoveInputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR o);
18414 export function CResult_TxRemoveInputDecodeErrorZ_is_ok(o: bigint): boolean {
18415 if(!isWasmInitialized) {
18416 throw new Error("initializeWasm() must be awaited first!");
18418 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_is_ok(o);
18419 return nativeResponseValue;
18421 // void CResult_TxRemoveInputDecodeErrorZ_free(struct LDKCResult_TxRemoveInputDecodeErrorZ _res);
18423 export function CResult_TxRemoveInputDecodeErrorZ_free(_res: bigint): void {
18424 if(!isWasmInitialized) {
18425 throw new Error("initializeWasm() must be awaited first!");
18427 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_free(_res);
18428 // debug statements here
18430 // uint64_t CResult_TxRemoveInputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR arg);
18432 export function CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18433 if(!isWasmInitialized) {
18434 throw new Error("initializeWasm() must be awaited first!");
18436 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg);
18437 return nativeResponseValue;
18439 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR orig);
18441 export function CResult_TxRemoveInputDecodeErrorZ_clone(orig: bigint): bigint {
18442 if(!isWasmInitialized) {
18443 throw new Error("initializeWasm() must be awaited first!");
18445 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone(orig);
18446 return nativeResponseValue;
18448 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_ok(struct LDKTxRemoveOutput o);
18450 export function CResult_TxRemoveOutputDecodeErrorZ_ok(o: bigint): bigint {
18451 if(!isWasmInitialized) {
18452 throw new Error("initializeWasm() must be awaited first!");
18454 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_ok(o);
18455 return nativeResponseValue;
18457 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_err(struct LDKDecodeError e);
18459 export function CResult_TxRemoveOutputDecodeErrorZ_err(e: bigint): bigint {
18460 if(!isWasmInitialized) {
18461 throw new Error("initializeWasm() must be awaited first!");
18463 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_err(e);
18464 return nativeResponseValue;
18466 // bool CResult_TxRemoveOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR o);
18468 export function CResult_TxRemoveOutputDecodeErrorZ_is_ok(o: bigint): boolean {
18469 if(!isWasmInitialized) {
18470 throw new Error("initializeWasm() must be awaited first!");
18472 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok(o);
18473 return nativeResponseValue;
18475 // void CResult_TxRemoveOutputDecodeErrorZ_free(struct LDKCResult_TxRemoveOutputDecodeErrorZ _res);
18477 export function CResult_TxRemoveOutputDecodeErrorZ_free(_res: bigint): void {
18478 if(!isWasmInitialized) {
18479 throw new Error("initializeWasm() must be awaited first!");
18481 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_free(_res);
18482 // debug statements here
18484 // uint64_t CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR arg);
18486 export function CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18487 if(!isWasmInitialized) {
18488 throw new Error("initializeWasm() must be awaited first!");
18490 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg);
18491 return nativeResponseValue;
18493 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR orig);
18495 export function CResult_TxRemoveOutputDecodeErrorZ_clone(orig: bigint): bigint {
18496 if(!isWasmInitialized) {
18497 throw new Error("initializeWasm() must be awaited first!");
18499 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone(orig);
18500 return nativeResponseValue;
18502 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_ok(struct LDKTxComplete o);
18504 export function CResult_TxCompleteDecodeErrorZ_ok(o: bigint): bigint {
18505 if(!isWasmInitialized) {
18506 throw new Error("initializeWasm() must be awaited first!");
18508 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_ok(o);
18509 return nativeResponseValue;
18511 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_err(struct LDKDecodeError e);
18513 export function CResult_TxCompleteDecodeErrorZ_err(e: bigint): bigint {
18514 if(!isWasmInitialized) {
18515 throw new Error("initializeWasm() must be awaited first!");
18517 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_err(e);
18518 return nativeResponseValue;
18520 // bool CResult_TxCompleteDecodeErrorZ_is_ok(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR o);
18522 export function CResult_TxCompleteDecodeErrorZ_is_ok(o: bigint): boolean {
18523 if(!isWasmInitialized) {
18524 throw new Error("initializeWasm() must be awaited first!");
18526 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_is_ok(o);
18527 return nativeResponseValue;
18529 // void CResult_TxCompleteDecodeErrorZ_free(struct LDKCResult_TxCompleteDecodeErrorZ _res);
18531 export function CResult_TxCompleteDecodeErrorZ_free(_res: bigint): void {
18532 if(!isWasmInitialized) {
18533 throw new Error("initializeWasm() must be awaited first!");
18535 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_free(_res);
18536 // debug statements here
18538 // uint64_t CResult_TxCompleteDecodeErrorZ_clone_ptr(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR arg);
18540 export function CResult_TxCompleteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18541 if(!isWasmInitialized) {
18542 throw new Error("initializeWasm() must be awaited first!");
18544 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone_ptr(arg);
18545 return nativeResponseValue;
18547 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_clone(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR orig);
18549 export function CResult_TxCompleteDecodeErrorZ_clone(orig: bigint): bigint {
18550 if(!isWasmInitialized) {
18551 throw new Error("initializeWasm() must be awaited first!");
18553 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone(orig);
18554 return nativeResponseValue;
18556 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_ok(struct LDKTxSignatures o);
18558 export function CResult_TxSignaturesDecodeErrorZ_ok(o: bigint): bigint {
18559 if(!isWasmInitialized) {
18560 throw new Error("initializeWasm() must be awaited first!");
18562 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_ok(o);
18563 return nativeResponseValue;
18565 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
18567 export function CResult_TxSignaturesDecodeErrorZ_err(e: bigint): bigint {
18568 if(!isWasmInitialized) {
18569 throw new Error("initializeWasm() must be awaited first!");
18571 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_err(e);
18572 return nativeResponseValue;
18574 // bool CResult_TxSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR o);
18576 export function CResult_TxSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
18577 if(!isWasmInitialized) {
18578 throw new Error("initializeWasm() must be awaited first!");
18580 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_is_ok(o);
18581 return nativeResponseValue;
18583 // void CResult_TxSignaturesDecodeErrorZ_free(struct LDKCResult_TxSignaturesDecodeErrorZ _res);
18585 export function CResult_TxSignaturesDecodeErrorZ_free(_res: bigint): void {
18586 if(!isWasmInitialized) {
18587 throw new Error("initializeWasm() must be awaited first!");
18589 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_free(_res);
18590 // debug statements here
18592 // uint64_t CResult_TxSignaturesDecodeErrorZ_clone_ptr(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR arg);
18594 export function CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18595 if(!isWasmInitialized) {
18596 throw new Error("initializeWasm() must be awaited first!");
18598 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg);
18599 return nativeResponseValue;
18601 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_clone(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR orig);
18603 export function CResult_TxSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
18604 if(!isWasmInitialized) {
18605 throw new Error("initializeWasm() must be awaited first!");
18607 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone(orig);
18608 return nativeResponseValue;
18610 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_ok(struct LDKTxInitRbf o);
18612 export function CResult_TxInitRbfDecodeErrorZ_ok(o: bigint): bigint {
18613 if(!isWasmInitialized) {
18614 throw new Error("initializeWasm() must be awaited first!");
18616 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_ok(o);
18617 return nativeResponseValue;
18619 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_err(struct LDKDecodeError e);
18621 export function CResult_TxInitRbfDecodeErrorZ_err(e: bigint): bigint {
18622 if(!isWasmInitialized) {
18623 throw new Error("initializeWasm() must be awaited first!");
18625 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_err(e);
18626 return nativeResponseValue;
18628 // bool CResult_TxInitRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR o);
18630 export function CResult_TxInitRbfDecodeErrorZ_is_ok(o: bigint): boolean {
18631 if(!isWasmInitialized) {
18632 throw new Error("initializeWasm() must be awaited first!");
18634 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_is_ok(o);
18635 return nativeResponseValue;
18637 // void CResult_TxInitRbfDecodeErrorZ_free(struct LDKCResult_TxInitRbfDecodeErrorZ _res);
18639 export function CResult_TxInitRbfDecodeErrorZ_free(_res: bigint): void {
18640 if(!isWasmInitialized) {
18641 throw new Error("initializeWasm() must be awaited first!");
18643 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_free(_res);
18644 // debug statements here
18646 // uint64_t CResult_TxInitRbfDecodeErrorZ_clone_ptr(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR arg);
18648 export function CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18649 if(!isWasmInitialized) {
18650 throw new Error("initializeWasm() must be awaited first!");
18652 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg);
18653 return nativeResponseValue;
18655 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_clone(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR orig);
18657 export function CResult_TxInitRbfDecodeErrorZ_clone(orig: bigint): bigint {
18658 if(!isWasmInitialized) {
18659 throw new Error("initializeWasm() must be awaited first!");
18661 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone(orig);
18662 return nativeResponseValue;
18664 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_ok(struct LDKTxAckRbf o);
18666 export function CResult_TxAckRbfDecodeErrorZ_ok(o: bigint): bigint {
18667 if(!isWasmInitialized) {
18668 throw new Error("initializeWasm() must be awaited first!");
18670 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_ok(o);
18671 return nativeResponseValue;
18673 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_err(struct LDKDecodeError e);
18675 export function CResult_TxAckRbfDecodeErrorZ_err(e: bigint): bigint {
18676 if(!isWasmInitialized) {
18677 throw new Error("initializeWasm() must be awaited first!");
18679 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_err(e);
18680 return nativeResponseValue;
18682 // bool CResult_TxAckRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR o);
18684 export function CResult_TxAckRbfDecodeErrorZ_is_ok(o: bigint): boolean {
18685 if(!isWasmInitialized) {
18686 throw new Error("initializeWasm() must be awaited first!");
18688 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_is_ok(o);
18689 return nativeResponseValue;
18691 // void CResult_TxAckRbfDecodeErrorZ_free(struct LDKCResult_TxAckRbfDecodeErrorZ _res);
18693 export function CResult_TxAckRbfDecodeErrorZ_free(_res: bigint): void {
18694 if(!isWasmInitialized) {
18695 throw new Error("initializeWasm() must be awaited first!");
18697 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_free(_res);
18698 // debug statements here
18700 // uint64_t CResult_TxAckRbfDecodeErrorZ_clone_ptr(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR arg);
18702 export function CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18703 if(!isWasmInitialized) {
18704 throw new Error("initializeWasm() must be awaited first!");
18706 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg);
18707 return nativeResponseValue;
18709 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_clone(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR orig);
18711 export function CResult_TxAckRbfDecodeErrorZ_clone(orig: bigint): bigint {
18712 if(!isWasmInitialized) {
18713 throw new Error("initializeWasm() must be awaited first!");
18715 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone(orig);
18716 return nativeResponseValue;
18718 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_ok(struct LDKTxAbort o);
18720 export function CResult_TxAbortDecodeErrorZ_ok(o: bigint): bigint {
18721 if(!isWasmInitialized) {
18722 throw new Error("initializeWasm() must be awaited first!");
18724 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_ok(o);
18725 return nativeResponseValue;
18727 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_err(struct LDKDecodeError e);
18729 export function CResult_TxAbortDecodeErrorZ_err(e: bigint): bigint {
18730 if(!isWasmInitialized) {
18731 throw new Error("initializeWasm() must be awaited first!");
18733 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_err(e);
18734 return nativeResponseValue;
18736 // bool CResult_TxAbortDecodeErrorZ_is_ok(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR o);
18738 export function CResult_TxAbortDecodeErrorZ_is_ok(o: bigint): boolean {
18739 if(!isWasmInitialized) {
18740 throw new Error("initializeWasm() must be awaited first!");
18742 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_is_ok(o);
18743 return nativeResponseValue;
18745 // void CResult_TxAbortDecodeErrorZ_free(struct LDKCResult_TxAbortDecodeErrorZ _res);
18747 export function CResult_TxAbortDecodeErrorZ_free(_res: bigint): void {
18748 if(!isWasmInitialized) {
18749 throw new Error("initializeWasm() must be awaited first!");
18751 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_free(_res);
18752 // debug statements here
18754 // uint64_t CResult_TxAbortDecodeErrorZ_clone_ptr(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR arg);
18756 export function CResult_TxAbortDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18757 if(!isWasmInitialized) {
18758 throw new Error("initializeWasm() must be awaited first!");
18760 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone_ptr(arg);
18761 return nativeResponseValue;
18763 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_clone(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR orig);
18765 export function CResult_TxAbortDecodeErrorZ_clone(orig: bigint): bigint {
18766 if(!isWasmInitialized) {
18767 throw new Error("initializeWasm() must be awaited first!");
18769 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone(orig);
18770 return nativeResponseValue;
18772 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
18774 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
18775 if(!isWasmInitialized) {
18776 throw new Error("initializeWasm() must be awaited first!");
18778 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
18779 return nativeResponseValue;
18781 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
18783 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
18784 if(!isWasmInitialized) {
18785 throw new Error("initializeWasm() must be awaited first!");
18787 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
18788 return nativeResponseValue;
18790 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
18792 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
18793 if(!isWasmInitialized) {
18794 throw new Error("initializeWasm() must be awaited first!");
18796 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
18797 return nativeResponseValue;
18799 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
18801 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
18802 if(!isWasmInitialized) {
18803 throw new Error("initializeWasm() must be awaited first!");
18805 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
18806 // debug statements here
18808 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
18810 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18811 if(!isWasmInitialized) {
18812 throw new Error("initializeWasm() must be awaited first!");
18814 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
18815 return nativeResponseValue;
18817 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
18819 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
18820 if(!isWasmInitialized) {
18821 throw new Error("initializeWasm() must be awaited first!");
18823 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
18824 return nativeResponseValue;
18826 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
18828 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
18829 if(!isWasmInitialized) {
18830 throw new Error("initializeWasm() must be awaited first!");
18832 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
18833 return nativeResponseValue;
18835 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
18837 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
18838 if(!isWasmInitialized) {
18839 throw new Error("initializeWasm() must be awaited first!");
18841 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
18842 return nativeResponseValue;
18844 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
18846 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
18847 if(!isWasmInitialized) {
18848 throw new Error("initializeWasm() must be awaited first!");
18850 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
18851 return nativeResponseValue;
18853 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
18855 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
18856 if(!isWasmInitialized) {
18857 throw new Error("initializeWasm() must be awaited first!");
18859 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
18860 // debug statements here
18862 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
18864 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18865 if(!isWasmInitialized) {
18866 throw new Error("initializeWasm() must be awaited first!");
18868 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
18869 return nativeResponseValue;
18871 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
18873 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
18874 if(!isWasmInitialized) {
18875 throw new Error("initializeWasm() must be awaited first!");
18877 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
18878 return nativeResponseValue;
18880 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
18882 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
18883 if(!isWasmInitialized) {
18884 throw new Error("initializeWasm() must be awaited first!");
18886 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
18887 return nativeResponseValue;
18889 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
18891 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
18892 if(!isWasmInitialized) {
18893 throw new Error("initializeWasm() must be awaited first!");
18895 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
18896 return nativeResponseValue;
18898 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
18900 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
18901 if(!isWasmInitialized) {
18902 throw new Error("initializeWasm() must be awaited first!");
18904 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
18905 return nativeResponseValue;
18907 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
18909 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
18910 if(!isWasmInitialized) {
18911 throw new Error("initializeWasm() must be awaited first!");
18913 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
18914 // debug statements here
18916 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
18918 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18919 if(!isWasmInitialized) {
18920 throw new Error("initializeWasm() must be awaited first!");
18922 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
18923 return nativeResponseValue;
18925 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
18927 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
18928 if(!isWasmInitialized) {
18929 throw new Error("initializeWasm() must be awaited first!");
18931 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
18932 return nativeResponseValue;
18934 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
18936 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
18937 if(!isWasmInitialized) {
18938 throw new Error("initializeWasm() must be awaited first!");
18940 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
18941 return nativeResponseValue;
18943 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
18945 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
18946 if(!isWasmInitialized) {
18947 throw new Error("initializeWasm() must be awaited first!");
18949 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
18950 return nativeResponseValue;
18952 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
18954 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
18955 if(!isWasmInitialized) {
18956 throw new Error("initializeWasm() must be awaited first!");
18958 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
18959 return nativeResponseValue;
18961 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
18963 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
18964 if(!isWasmInitialized) {
18965 throw new Error("initializeWasm() must be awaited first!");
18967 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
18968 // debug statements here
18970 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
18972 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18973 if(!isWasmInitialized) {
18974 throw new Error("initializeWasm() must be awaited first!");
18976 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
18977 return nativeResponseValue;
18979 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
18981 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
18982 if(!isWasmInitialized) {
18983 throw new Error("initializeWasm() must be awaited first!");
18985 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
18986 return nativeResponseValue;
18988 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
18990 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
18991 if(!isWasmInitialized) {
18992 throw new Error("initializeWasm() must be awaited first!");
18994 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
18995 return nativeResponseValue;
18997 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
18999 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
19000 if(!isWasmInitialized) {
19001 throw new Error("initializeWasm() must be awaited first!");
19003 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
19004 return nativeResponseValue;
19006 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
19008 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
19009 if(!isWasmInitialized) {
19010 throw new Error("initializeWasm() must be awaited first!");
19012 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
19013 return nativeResponseValue;
19015 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
19017 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
19018 if(!isWasmInitialized) {
19019 throw new Error("initializeWasm() must be awaited first!");
19021 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
19022 // debug statements here
19024 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
19026 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19027 if(!isWasmInitialized) {
19028 throw new Error("initializeWasm() must be awaited first!");
19030 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
19031 return nativeResponseValue;
19033 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
19035 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
19036 if(!isWasmInitialized) {
19037 throw new Error("initializeWasm() must be awaited first!");
19039 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
19040 return nativeResponseValue;
19042 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
19044 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
19045 if(!isWasmInitialized) {
19046 throw new Error("initializeWasm() must be awaited first!");
19048 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
19049 return nativeResponseValue;
19051 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
19053 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
19054 if(!isWasmInitialized) {
19055 throw new Error("initializeWasm() must be awaited first!");
19057 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
19058 return nativeResponseValue;
19060 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
19062 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
19063 if(!isWasmInitialized) {
19064 throw new Error("initializeWasm() must be awaited first!");
19066 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
19067 return nativeResponseValue;
19069 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
19071 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
19072 if(!isWasmInitialized) {
19073 throw new Error("initializeWasm() must be awaited first!");
19075 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
19076 // debug statements here
19078 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
19080 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19081 if(!isWasmInitialized) {
19082 throw new Error("initializeWasm() must be awaited first!");
19084 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
19085 return nativeResponseValue;
19087 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
19089 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
19090 if(!isWasmInitialized) {
19091 throw new Error("initializeWasm() must be awaited first!");
19093 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
19094 return nativeResponseValue;
19096 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
19098 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
19099 if(!isWasmInitialized) {
19100 throw new Error("initializeWasm() must be awaited first!");
19102 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
19103 return nativeResponseValue;
19105 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
19107 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
19108 if(!isWasmInitialized) {
19109 throw new Error("initializeWasm() must be awaited first!");
19111 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
19112 return nativeResponseValue;
19114 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
19116 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
19117 if(!isWasmInitialized) {
19118 throw new Error("initializeWasm() must be awaited first!");
19120 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
19121 return nativeResponseValue;
19123 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
19125 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
19126 if(!isWasmInitialized) {
19127 throw new Error("initializeWasm() must be awaited first!");
19129 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
19130 // debug statements here
19132 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
19134 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19135 if(!isWasmInitialized) {
19136 throw new Error("initializeWasm() must be awaited first!");
19138 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
19139 return nativeResponseValue;
19141 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
19143 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
19144 if(!isWasmInitialized) {
19145 throw new Error("initializeWasm() must be awaited first!");
19147 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
19148 return nativeResponseValue;
19150 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
19152 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
19153 if(!isWasmInitialized) {
19154 throw new Error("initializeWasm() must be awaited first!");
19156 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
19157 return nativeResponseValue;
19159 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
19161 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
19162 if(!isWasmInitialized) {
19163 throw new Error("initializeWasm() must be awaited first!");
19165 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
19166 return nativeResponseValue;
19168 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
19170 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
19171 if(!isWasmInitialized) {
19172 throw new Error("initializeWasm() must be awaited first!");
19174 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
19175 return nativeResponseValue;
19177 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
19179 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
19180 if(!isWasmInitialized) {
19181 throw new Error("initializeWasm() must be awaited first!");
19183 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
19184 // debug statements here
19186 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
19188 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19189 if(!isWasmInitialized) {
19190 throw new Error("initializeWasm() must be awaited first!");
19192 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
19193 return nativeResponseValue;
19195 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
19197 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
19198 if(!isWasmInitialized) {
19199 throw new Error("initializeWasm() must be awaited first!");
19201 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
19202 return nativeResponseValue;
19204 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
19206 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
19207 if(!isWasmInitialized) {
19208 throw new Error("initializeWasm() must be awaited first!");
19210 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
19211 return nativeResponseValue;
19213 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
19215 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
19216 if(!isWasmInitialized) {
19217 throw new Error("initializeWasm() must be awaited first!");
19219 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
19220 return nativeResponseValue;
19222 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
19224 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
19225 if(!isWasmInitialized) {
19226 throw new Error("initializeWasm() must be awaited first!");
19228 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
19229 return nativeResponseValue;
19231 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
19233 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
19234 if(!isWasmInitialized) {
19235 throw new Error("initializeWasm() must be awaited first!");
19237 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
19238 // debug statements here
19240 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
19242 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19243 if(!isWasmInitialized) {
19244 throw new Error("initializeWasm() must be awaited first!");
19246 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
19247 return nativeResponseValue;
19249 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
19251 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
19252 if(!isWasmInitialized) {
19253 throw new Error("initializeWasm() must be awaited first!");
19255 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
19256 return nativeResponseValue;
19258 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
19260 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
19261 if(!isWasmInitialized) {
19262 throw new Error("initializeWasm() must be awaited first!");
19264 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
19265 return nativeResponseValue;
19267 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
19269 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
19270 if(!isWasmInitialized) {
19271 throw new Error("initializeWasm() must be awaited first!");
19273 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
19274 return nativeResponseValue;
19276 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
19278 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
19279 if(!isWasmInitialized) {
19280 throw new Error("initializeWasm() must be awaited first!");
19282 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
19283 return nativeResponseValue;
19285 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
19287 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
19288 if(!isWasmInitialized) {
19289 throw new Error("initializeWasm() must be awaited first!");
19291 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
19292 // debug statements here
19294 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
19296 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19297 if(!isWasmInitialized) {
19298 throw new Error("initializeWasm() must be awaited first!");
19300 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
19301 return nativeResponseValue;
19303 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
19305 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
19306 if(!isWasmInitialized) {
19307 throw new Error("initializeWasm() must be awaited first!");
19309 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
19310 return nativeResponseValue;
19312 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_ok(struct LDKOpenChannelV2 o);
19314 export function CResult_OpenChannelV2DecodeErrorZ_ok(o: bigint): bigint {
19315 if(!isWasmInitialized) {
19316 throw new Error("initializeWasm() must be awaited first!");
19318 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_ok(o);
19319 return nativeResponseValue;
19321 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
19323 export function CResult_OpenChannelV2DecodeErrorZ_err(e: bigint): bigint {
19324 if(!isWasmInitialized) {
19325 throw new Error("initializeWasm() must be awaited first!");
19327 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_err(e);
19328 return nativeResponseValue;
19330 // bool CResult_OpenChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR o);
19332 export function CResult_OpenChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
19333 if(!isWasmInitialized) {
19334 throw new Error("initializeWasm() must be awaited first!");
19336 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_is_ok(o);
19337 return nativeResponseValue;
19339 // void CResult_OpenChannelV2DecodeErrorZ_free(struct LDKCResult_OpenChannelV2DecodeErrorZ _res);
19341 export function CResult_OpenChannelV2DecodeErrorZ_free(_res: bigint): void {
19342 if(!isWasmInitialized) {
19343 throw new Error("initializeWasm() must be awaited first!");
19345 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_free(_res);
19346 // debug statements here
19348 // uint64_t CResult_OpenChannelV2DecodeErrorZ_clone_ptr(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR arg);
19350 export function CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
19351 if(!isWasmInitialized) {
19352 throw new Error("initializeWasm() must be awaited first!");
19354 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg);
19355 return nativeResponseValue;
19357 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_clone(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR orig);
19359 export function CResult_OpenChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
19360 if(!isWasmInitialized) {
19361 throw new Error("initializeWasm() must be awaited first!");
19363 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone(orig);
19364 return nativeResponseValue;
19366 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
19368 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
19369 if(!isWasmInitialized) {
19370 throw new Error("initializeWasm() must be awaited first!");
19372 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
19373 return nativeResponseValue;
19375 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
19377 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
19378 if(!isWasmInitialized) {
19379 throw new Error("initializeWasm() must be awaited first!");
19381 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
19382 return nativeResponseValue;
19384 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
19386 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
19387 if(!isWasmInitialized) {
19388 throw new Error("initializeWasm() must be awaited first!");
19390 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
19391 return nativeResponseValue;
19393 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
19395 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
19396 if(!isWasmInitialized) {
19397 throw new Error("initializeWasm() must be awaited first!");
19399 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
19400 // debug statements here
19402 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
19404 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19405 if(!isWasmInitialized) {
19406 throw new Error("initializeWasm() must be awaited first!");
19408 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
19409 return nativeResponseValue;
19411 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
19413 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
19414 if(!isWasmInitialized) {
19415 throw new Error("initializeWasm() must be awaited first!");
19417 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
19418 return nativeResponseValue;
19420 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
19422 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
19423 if(!isWasmInitialized) {
19424 throw new Error("initializeWasm() must be awaited first!");
19426 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
19427 return nativeResponseValue;
19429 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
19431 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
19432 if(!isWasmInitialized) {
19433 throw new Error("initializeWasm() must be awaited first!");
19435 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
19436 return nativeResponseValue;
19438 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
19440 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
19441 if(!isWasmInitialized) {
19442 throw new Error("initializeWasm() must be awaited first!");
19444 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
19445 return nativeResponseValue;
19447 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
19449 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
19450 if(!isWasmInitialized) {
19451 throw new Error("initializeWasm() must be awaited first!");
19453 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
19454 // debug statements here
19456 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
19458 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19459 if(!isWasmInitialized) {
19460 throw new Error("initializeWasm() must be awaited first!");
19462 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
19463 return nativeResponseValue;
19465 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
19467 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
19468 if(!isWasmInitialized) {
19469 throw new Error("initializeWasm() must be awaited first!");
19471 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
19472 return nativeResponseValue;
19474 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
19476 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
19477 if(!isWasmInitialized) {
19478 throw new Error("initializeWasm() must be awaited first!");
19480 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
19481 return nativeResponseValue;
19483 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
19485 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
19486 if(!isWasmInitialized) {
19487 throw new Error("initializeWasm() must be awaited first!");
19489 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
19490 return nativeResponseValue;
19492 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
19494 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
19495 if(!isWasmInitialized) {
19496 throw new Error("initializeWasm() must be awaited first!");
19498 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
19499 return nativeResponseValue;
19501 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
19503 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
19504 if(!isWasmInitialized) {
19505 throw new Error("initializeWasm() must be awaited first!");
19507 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
19508 // debug statements here
19510 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
19512 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19513 if(!isWasmInitialized) {
19514 throw new Error("initializeWasm() must be awaited first!");
19516 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
19517 return nativeResponseValue;
19519 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
19521 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
19522 if(!isWasmInitialized) {
19523 throw new Error("initializeWasm() must be awaited first!");
19525 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
19526 return nativeResponseValue;
19528 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
19530 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
19531 if(!isWasmInitialized) {
19532 throw new Error("initializeWasm() must be awaited first!");
19534 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
19535 return nativeResponseValue;
19537 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
19539 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
19540 if(!isWasmInitialized) {
19541 throw new Error("initializeWasm() must be awaited first!");
19543 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
19544 return nativeResponseValue;
19546 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
19548 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
19549 if(!isWasmInitialized) {
19550 throw new Error("initializeWasm() must be awaited first!");
19552 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
19553 return nativeResponseValue;
19555 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
19557 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
19558 if(!isWasmInitialized) {
19559 throw new Error("initializeWasm() must be awaited first!");
19561 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
19562 // debug statements here
19564 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
19566 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19567 if(!isWasmInitialized) {
19568 throw new Error("initializeWasm() must be awaited first!");
19570 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
19571 return nativeResponseValue;
19573 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
19575 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
19576 if(!isWasmInitialized) {
19577 throw new Error("initializeWasm() must be awaited first!");
19579 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
19580 return nativeResponseValue;
19582 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
19584 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
19585 if(!isWasmInitialized) {
19586 throw new Error("initializeWasm() must be awaited first!");
19588 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
19589 return nativeResponseValue;
19591 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
19593 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
19594 if(!isWasmInitialized) {
19595 throw new Error("initializeWasm() must be awaited first!");
19597 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
19598 return nativeResponseValue;
19600 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
19602 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
19603 if(!isWasmInitialized) {
19604 throw new Error("initializeWasm() must be awaited first!");
19606 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
19607 return nativeResponseValue;
19609 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
19611 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
19612 if(!isWasmInitialized) {
19613 throw new Error("initializeWasm() must be awaited first!");
19615 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
19616 // debug statements here
19618 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
19620 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19621 if(!isWasmInitialized) {
19622 throw new Error("initializeWasm() must be awaited first!");
19624 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
19625 return nativeResponseValue;
19627 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
19629 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
19630 if(!isWasmInitialized) {
19631 throw new Error("initializeWasm() must be awaited first!");
19633 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
19634 return nativeResponseValue;
19636 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
19638 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
19639 if(!isWasmInitialized) {
19640 throw new Error("initializeWasm() must be awaited first!");
19642 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
19643 return nativeResponseValue;
19645 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
19647 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
19648 if(!isWasmInitialized) {
19649 throw new Error("initializeWasm() must be awaited first!");
19651 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
19652 return nativeResponseValue;
19654 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
19656 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
19657 if(!isWasmInitialized) {
19658 throw new Error("initializeWasm() must be awaited first!");
19660 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
19661 return nativeResponseValue;
19663 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
19665 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
19666 if(!isWasmInitialized) {
19667 throw new Error("initializeWasm() must be awaited first!");
19669 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
19670 // debug statements here
19672 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
19674 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19675 if(!isWasmInitialized) {
19676 throw new Error("initializeWasm() must be awaited first!");
19678 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
19679 return nativeResponseValue;
19681 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
19683 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
19684 if(!isWasmInitialized) {
19685 throw new Error("initializeWasm() must be awaited first!");
19687 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
19688 return nativeResponseValue;
19690 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
19692 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
19693 if(!isWasmInitialized) {
19694 throw new Error("initializeWasm() must be awaited first!");
19696 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
19697 return nativeResponseValue;
19699 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
19701 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
19702 if(!isWasmInitialized) {
19703 throw new Error("initializeWasm() must be awaited first!");
19705 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
19706 return nativeResponseValue;
19708 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
19710 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
19711 if(!isWasmInitialized) {
19712 throw new Error("initializeWasm() must be awaited first!");
19714 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
19715 return nativeResponseValue;
19717 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
19719 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
19720 if(!isWasmInitialized) {
19721 throw new Error("initializeWasm() must be awaited first!");
19723 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
19724 // debug statements here
19726 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
19728 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19729 if(!isWasmInitialized) {
19730 throw new Error("initializeWasm() must be awaited first!");
19732 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
19733 return nativeResponseValue;
19735 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
19737 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
19738 if(!isWasmInitialized) {
19739 throw new Error("initializeWasm() must be awaited first!");
19741 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
19742 return nativeResponseValue;
19744 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
19746 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
19747 if(!isWasmInitialized) {
19748 throw new Error("initializeWasm() must be awaited first!");
19750 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
19751 return nativeResponseValue;
19753 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
19755 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
19756 if(!isWasmInitialized) {
19757 throw new Error("initializeWasm() must be awaited first!");
19759 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
19760 return nativeResponseValue;
19762 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
19764 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
19765 if(!isWasmInitialized) {
19766 throw new Error("initializeWasm() must be awaited first!");
19768 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
19769 return nativeResponseValue;
19771 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
19773 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
19774 if(!isWasmInitialized) {
19775 throw new Error("initializeWasm() must be awaited first!");
19777 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
19778 // debug statements here
19780 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
19782 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19783 if(!isWasmInitialized) {
19784 throw new Error("initializeWasm() must be awaited first!");
19786 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
19787 return nativeResponseValue;
19789 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
19791 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
19792 if(!isWasmInitialized) {
19793 throw new Error("initializeWasm() must be awaited first!");
19795 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
19796 return nativeResponseValue;
19798 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
19800 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
19801 if(!isWasmInitialized) {
19802 throw new Error("initializeWasm() must be awaited first!");
19804 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
19805 return nativeResponseValue;
19807 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
19809 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
19810 if(!isWasmInitialized) {
19811 throw new Error("initializeWasm() must be awaited first!");
19813 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
19814 return nativeResponseValue;
19816 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
19818 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
19819 if(!isWasmInitialized) {
19820 throw new Error("initializeWasm() must be awaited first!");
19822 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
19823 return nativeResponseValue;
19825 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
19827 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
19828 if(!isWasmInitialized) {
19829 throw new Error("initializeWasm() must be awaited first!");
19831 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
19832 // debug statements here
19834 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
19836 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19837 if(!isWasmInitialized) {
19838 throw new Error("initializeWasm() must be awaited first!");
19840 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
19841 return nativeResponseValue;
19843 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
19845 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
19846 if(!isWasmInitialized) {
19847 throw new Error("initializeWasm() must be awaited first!");
19849 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
19850 return nativeResponseValue;
19852 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
19854 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
19855 if(!isWasmInitialized) {
19856 throw new Error("initializeWasm() must be awaited first!");
19858 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
19859 return nativeResponseValue;
19861 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
19863 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
19864 if(!isWasmInitialized) {
19865 throw new Error("initializeWasm() must be awaited first!");
19867 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
19868 return nativeResponseValue;
19870 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
19872 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
19873 if(!isWasmInitialized) {
19874 throw new Error("initializeWasm() must be awaited first!");
19876 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
19877 return nativeResponseValue;
19879 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
19881 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
19882 if(!isWasmInitialized) {
19883 throw new Error("initializeWasm() must be awaited first!");
19885 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
19886 // debug statements here
19888 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
19890 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19891 if(!isWasmInitialized) {
19892 throw new Error("initializeWasm() must be awaited first!");
19894 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
19895 return nativeResponseValue;
19897 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
19899 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
19900 if(!isWasmInitialized) {
19901 throw new Error("initializeWasm() must be awaited first!");
19903 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
19904 return nativeResponseValue;
19906 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
19908 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
19909 if(!isWasmInitialized) {
19910 throw new Error("initializeWasm() must be awaited first!");
19912 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
19913 return nativeResponseValue;
19915 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
19917 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
19918 if(!isWasmInitialized) {
19919 throw new Error("initializeWasm() must be awaited first!");
19921 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
19922 return nativeResponseValue;
19924 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
19926 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
19927 if(!isWasmInitialized) {
19928 throw new Error("initializeWasm() must be awaited first!");
19930 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
19931 return nativeResponseValue;
19933 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
19935 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
19936 if(!isWasmInitialized) {
19937 throw new Error("initializeWasm() must be awaited first!");
19939 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
19940 // debug statements here
19942 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
19944 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19945 if(!isWasmInitialized) {
19946 throw new Error("initializeWasm() must be awaited first!");
19948 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
19949 return nativeResponseValue;
19951 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
19953 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
19954 if(!isWasmInitialized) {
19955 throw new Error("initializeWasm() must be awaited first!");
19957 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
19958 return nativeResponseValue;
19960 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
19962 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
19963 if(!isWasmInitialized) {
19964 throw new Error("initializeWasm() must be awaited first!");
19966 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
19967 return nativeResponseValue;
19969 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
19971 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
19972 if(!isWasmInitialized) {
19973 throw new Error("initializeWasm() must be awaited first!");
19975 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
19976 return nativeResponseValue;
19978 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
19980 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
19981 if(!isWasmInitialized) {
19982 throw new Error("initializeWasm() must be awaited first!");
19984 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
19985 return nativeResponseValue;
19987 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
19989 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
19990 if(!isWasmInitialized) {
19991 throw new Error("initializeWasm() must be awaited first!");
19993 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
19994 // debug statements here
19996 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
19998 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19999 if(!isWasmInitialized) {
20000 throw new Error("initializeWasm() must be awaited first!");
20002 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
20003 return nativeResponseValue;
20005 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20007 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20008 if(!isWasmInitialized) {
20009 throw new Error("initializeWasm() must be awaited first!");
20011 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
20012 return nativeResponseValue;
20014 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
20016 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
20017 if(!isWasmInitialized) {
20018 throw new Error("initializeWasm() must be awaited first!");
20020 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
20021 return nativeResponseValue;
20023 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
20025 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
20026 if(!isWasmInitialized) {
20027 throw new Error("initializeWasm() must be awaited first!");
20029 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
20030 return nativeResponseValue;
20032 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
20034 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
20035 if(!isWasmInitialized) {
20036 throw new Error("initializeWasm() must be awaited first!");
20038 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
20039 return nativeResponseValue;
20041 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
20043 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
20044 if(!isWasmInitialized) {
20045 throw new Error("initializeWasm() must be awaited first!");
20047 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
20048 // debug statements here
20050 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
20052 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20053 if(!isWasmInitialized) {
20054 throw new Error("initializeWasm() must be awaited first!");
20056 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
20057 return nativeResponseValue;
20059 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
20061 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
20062 if(!isWasmInitialized) {
20063 throw new Error("initializeWasm() must be awaited first!");
20065 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
20066 return nativeResponseValue;
20068 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
20070 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
20071 if(!isWasmInitialized) {
20072 throw new Error("initializeWasm() must be awaited first!");
20074 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
20075 return nativeResponseValue;
20077 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
20079 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
20080 if(!isWasmInitialized) {
20081 throw new Error("initializeWasm() must be awaited first!");
20083 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
20084 return nativeResponseValue;
20086 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
20088 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
20089 if(!isWasmInitialized) {
20090 throw new Error("initializeWasm() must be awaited first!");
20092 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
20093 return nativeResponseValue;
20095 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
20097 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
20098 if(!isWasmInitialized) {
20099 throw new Error("initializeWasm() must be awaited first!");
20101 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
20102 // debug statements here
20104 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
20106 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20107 if(!isWasmInitialized) {
20108 throw new Error("initializeWasm() must be awaited first!");
20110 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
20111 return nativeResponseValue;
20113 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
20115 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
20116 if(!isWasmInitialized) {
20117 throw new Error("initializeWasm() must be awaited first!");
20119 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
20120 return nativeResponseValue;
20122 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
20124 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
20125 if(!isWasmInitialized) {
20126 throw new Error("initializeWasm() must be awaited first!");
20128 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
20129 return nativeResponseValue;
20131 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
20133 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
20134 if(!isWasmInitialized) {
20135 throw new Error("initializeWasm() must be awaited first!");
20137 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
20138 return nativeResponseValue;
20140 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
20142 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
20143 if(!isWasmInitialized) {
20144 throw new Error("initializeWasm() must be awaited first!");
20146 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
20147 return nativeResponseValue;
20149 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
20151 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
20152 if(!isWasmInitialized) {
20153 throw new Error("initializeWasm() must be awaited first!");
20155 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
20156 // debug statements here
20158 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
20160 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20161 if(!isWasmInitialized) {
20162 throw new Error("initializeWasm() must be awaited first!");
20164 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
20165 return nativeResponseValue;
20167 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
20169 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
20170 if(!isWasmInitialized) {
20171 throw new Error("initializeWasm() must be awaited first!");
20173 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
20174 return nativeResponseValue;
20176 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
20178 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
20179 if(!isWasmInitialized) {
20180 throw new Error("initializeWasm() must be awaited first!");
20182 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
20183 return nativeResponseValue;
20185 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
20187 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
20188 if(!isWasmInitialized) {
20189 throw new Error("initializeWasm() must be awaited first!");
20191 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
20192 return nativeResponseValue;
20194 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
20196 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
20197 if(!isWasmInitialized) {
20198 throw new Error("initializeWasm() must be awaited first!");
20200 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
20201 return nativeResponseValue;
20203 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
20205 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
20206 if(!isWasmInitialized) {
20207 throw new Error("initializeWasm() must be awaited first!");
20209 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
20210 // debug statements here
20212 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
20214 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20215 if(!isWasmInitialized) {
20216 throw new Error("initializeWasm() must be awaited first!");
20218 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
20219 return nativeResponseValue;
20221 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
20223 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
20224 if(!isWasmInitialized) {
20225 throw new Error("initializeWasm() must be awaited first!");
20227 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
20228 return nativeResponseValue;
20230 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
20232 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
20233 if(!isWasmInitialized) {
20234 throw new Error("initializeWasm() must be awaited first!");
20236 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
20237 return nativeResponseValue;
20239 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
20241 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
20242 if(!isWasmInitialized) {
20243 throw new Error("initializeWasm() must be awaited first!");
20245 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
20246 return nativeResponseValue;
20248 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
20250 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
20251 if(!isWasmInitialized) {
20252 throw new Error("initializeWasm() must be awaited first!");
20254 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
20255 return nativeResponseValue;
20257 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
20259 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
20260 if(!isWasmInitialized) {
20261 throw new Error("initializeWasm() must be awaited first!");
20263 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
20264 // debug statements here
20266 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
20268 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20269 if(!isWasmInitialized) {
20270 throw new Error("initializeWasm() must be awaited first!");
20272 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
20273 return nativeResponseValue;
20275 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20277 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20278 if(!isWasmInitialized) {
20279 throw new Error("initializeWasm() must be awaited first!");
20281 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
20282 return nativeResponseValue;
20284 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
20286 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
20287 if(!isWasmInitialized) {
20288 throw new Error("initializeWasm() must be awaited first!");
20290 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
20291 return nativeResponseValue;
20293 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
20295 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
20296 if(!isWasmInitialized) {
20297 throw new Error("initializeWasm() must be awaited first!");
20299 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
20300 return nativeResponseValue;
20302 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
20304 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
20305 if(!isWasmInitialized) {
20306 throw new Error("initializeWasm() must be awaited first!");
20308 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
20309 return nativeResponseValue;
20311 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
20313 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
20314 if(!isWasmInitialized) {
20315 throw new Error("initializeWasm() must be awaited first!");
20317 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
20318 // debug statements here
20320 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
20322 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20323 if(!isWasmInitialized) {
20324 throw new Error("initializeWasm() must be awaited first!");
20326 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
20327 return nativeResponseValue;
20329 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20331 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20332 if(!isWasmInitialized) {
20333 throw new Error("initializeWasm() must be awaited first!");
20335 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
20336 return nativeResponseValue;
20338 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
20340 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
20341 if(!isWasmInitialized) {
20342 throw new Error("initializeWasm() must be awaited first!");
20344 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
20345 return nativeResponseValue;
20347 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
20349 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
20350 if(!isWasmInitialized) {
20351 throw new Error("initializeWasm() must be awaited first!");
20353 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
20354 return nativeResponseValue;
20356 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
20358 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
20359 if(!isWasmInitialized) {
20360 throw new Error("initializeWasm() must be awaited first!");
20362 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
20363 return nativeResponseValue;
20365 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
20367 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
20368 if(!isWasmInitialized) {
20369 throw new Error("initializeWasm() must be awaited first!");
20371 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
20372 // debug statements here
20374 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
20376 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20377 if(!isWasmInitialized) {
20378 throw new Error("initializeWasm() must be awaited first!");
20380 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
20381 return nativeResponseValue;
20383 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
20385 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
20386 if(!isWasmInitialized) {
20387 throw new Error("initializeWasm() must be awaited first!");
20389 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
20390 return nativeResponseValue;
20392 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
20394 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
20395 if(!isWasmInitialized) {
20396 throw new Error("initializeWasm() must be awaited first!");
20398 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
20399 return nativeResponseValue;
20401 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
20403 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
20404 if(!isWasmInitialized) {
20405 throw new Error("initializeWasm() must be awaited first!");
20407 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
20408 return nativeResponseValue;
20410 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
20412 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
20413 if(!isWasmInitialized) {
20414 throw new Error("initializeWasm() must be awaited first!");
20416 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
20417 return nativeResponseValue;
20419 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
20421 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
20422 if(!isWasmInitialized) {
20423 throw new Error("initializeWasm() must be awaited first!");
20425 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
20426 // debug statements here
20428 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
20430 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20431 if(!isWasmInitialized) {
20432 throw new Error("initializeWasm() must be awaited first!");
20434 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
20435 return nativeResponseValue;
20437 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
20439 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
20440 if(!isWasmInitialized) {
20441 throw new Error("initializeWasm() must be awaited first!");
20443 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
20444 return nativeResponseValue;
20446 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
20448 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
20449 if(!isWasmInitialized) {
20450 throw new Error("initializeWasm() must be awaited first!");
20452 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
20453 return nativeResponseValue;
20455 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
20457 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
20458 if(!isWasmInitialized) {
20459 throw new Error("initializeWasm() must be awaited first!");
20461 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
20462 return nativeResponseValue;
20464 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
20466 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
20467 if(!isWasmInitialized) {
20468 throw new Error("initializeWasm() must be awaited first!");
20470 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
20471 return nativeResponseValue;
20473 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
20475 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
20476 if(!isWasmInitialized) {
20477 throw new Error("initializeWasm() must be awaited first!");
20479 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
20480 // debug statements here
20482 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
20484 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20485 if(!isWasmInitialized) {
20486 throw new Error("initializeWasm() must be awaited first!");
20488 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
20489 return nativeResponseValue;
20491 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
20493 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
20494 if(!isWasmInitialized) {
20495 throw new Error("initializeWasm() must be awaited first!");
20497 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
20498 return nativeResponseValue;
20500 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
20502 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
20503 if(!isWasmInitialized) {
20504 throw new Error("initializeWasm() must be awaited first!");
20506 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
20507 return nativeResponseValue;
20509 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
20511 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
20512 if(!isWasmInitialized) {
20513 throw new Error("initializeWasm() must be awaited first!");
20515 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
20516 return nativeResponseValue;
20518 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
20520 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
20521 if(!isWasmInitialized) {
20522 throw new Error("initializeWasm() must be awaited first!");
20524 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
20525 return nativeResponseValue;
20527 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
20529 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
20530 if(!isWasmInitialized) {
20531 throw new Error("initializeWasm() must be awaited first!");
20533 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
20534 // debug statements here
20536 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
20538 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20539 if(!isWasmInitialized) {
20540 throw new Error("initializeWasm() must be awaited first!");
20542 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
20543 return nativeResponseValue;
20545 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
20547 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
20548 if(!isWasmInitialized) {
20549 throw new Error("initializeWasm() must be awaited first!");
20551 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
20552 return nativeResponseValue;
20554 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
20556 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
20557 if(!isWasmInitialized) {
20558 throw new Error("initializeWasm() must be awaited first!");
20560 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
20561 return nativeResponseValue;
20563 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
20565 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
20566 if(!isWasmInitialized) {
20567 throw new Error("initializeWasm() must be awaited first!");
20569 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
20570 return nativeResponseValue;
20572 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
20574 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
20575 if(!isWasmInitialized) {
20576 throw new Error("initializeWasm() must be awaited first!");
20578 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
20579 return nativeResponseValue;
20581 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
20583 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
20584 if(!isWasmInitialized) {
20585 throw new Error("initializeWasm() must be awaited first!");
20587 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
20588 // debug statements here
20590 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
20592 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20593 if(!isWasmInitialized) {
20594 throw new Error("initializeWasm() must be awaited first!");
20596 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
20597 return nativeResponseValue;
20599 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
20601 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
20602 if(!isWasmInitialized) {
20603 throw new Error("initializeWasm() must be awaited first!");
20605 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
20606 return nativeResponseValue;
20608 // void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
20610 export function CVec_PhantomRouteHintsZ_free(_res: number): void {
20611 if(!isWasmInitialized) {
20612 throw new Error("initializeWasm() must be awaited first!");
20614 const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
20615 // debug statements here
20617 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(struct LDKBolt11Invoice o);
20619 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
20620 if(!isWasmInitialized) {
20621 throw new Error("initializeWasm() must be awaited first!");
20623 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o);
20624 return nativeResponseValue;
20626 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
20628 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
20629 if(!isWasmInitialized) {
20630 throw new Error("initializeWasm() must be awaited first!");
20632 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e);
20633 return nativeResponseValue;
20635 // bool CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
20637 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
20638 if(!isWasmInitialized) {
20639 throw new Error("initializeWasm() must be awaited first!");
20641 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o);
20642 return nativeResponseValue;
20644 // void CResult_Bolt11InvoiceSignOrCreationErrorZ_free(struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ _res);
20646 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
20647 if(!isWasmInitialized) {
20648 throw new Error("initializeWasm() must be awaited first!");
20650 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res);
20651 // debug statements here
20653 // uint64_t CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
20655 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
20656 if(!isWasmInitialized) {
20657 throw new Error("initializeWasm() must be awaited first!");
20659 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg);
20660 return nativeResponseValue;
20662 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
20664 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
20665 if(!isWasmInitialized) {
20666 throw new Error("initializeWasm() must be awaited first!");
20668 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig);
20669 return nativeResponseValue;
20671 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_ok(struct LDKOffersMessage o);
20673 export function CResult_OffersMessageDecodeErrorZ_ok(o: bigint): bigint {
20674 if(!isWasmInitialized) {
20675 throw new Error("initializeWasm() must be awaited first!");
20677 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_ok(o);
20678 return nativeResponseValue;
20680 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_err(struct LDKDecodeError e);
20682 export function CResult_OffersMessageDecodeErrorZ_err(e: bigint): bigint {
20683 if(!isWasmInitialized) {
20684 throw new Error("initializeWasm() must be awaited first!");
20686 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_err(e);
20687 return nativeResponseValue;
20689 // bool CResult_OffersMessageDecodeErrorZ_is_ok(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR o);
20691 export function CResult_OffersMessageDecodeErrorZ_is_ok(o: bigint): boolean {
20692 if(!isWasmInitialized) {
20693 throw new Error("initializeWasm() must be awaited first!");
20695 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_is_ok(o);
20696 return nativeResponseValue;
20698 // void CResult_OffersMessageDecodeErrorZ_free(struct LDKCResult_OffersMessageDecodeErrorZ _res);
20700 export function CResult_OffersMessageDecodeErrorZ_free(_res: bigint): void {
20701 if(!isWasmInitialized) {
20702 throw new Error("initializeWasm() must be awaited first!");
20704 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_free(_res);
20705 // debug statements here
20707 // uint64_t CResult_OffersMessageDecodeErrorZ_clone_ptr(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR arg);
20709 export function CResult_OffersMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20710 if(!isWasmInitialized) {
20711 throw new Error("initializeWasm() must be awaited first!");
20713 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone_ptr(arg);
20714 return nativeResponseValue;
20716 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_clone(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR orig);
20718 export function CResult_OffersMessageDecodeErrorZ_clone(orig: bigint): bigint {
20719 if(!isWasmInitialized) {
20720 throw new Error("initializeWasm() must be awaited first!");
20722 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone(orig);
20723 return nativeResponseValue;
20725 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
20727 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
20728 if(!isWasmInitialized) {
20729 throw new Error("initializeWasm() must be awaited first!");
20731 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
20732 return nativeResponseValue;
20734 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
20736 export function COption_HTLCClaimZ_none(): bigint {
20737 if(!isWasmInitialized) {
20738 throw new Error("initializeWasm() must be awaited first!");
20740 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
20741 return nativeResponseValue;
20743 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
20745 export function COption_HTLCClaimZ_free(_res: bigint): void {
20746 if(!isWasmInitialized) {
20747 throw new Error("initializeWasm() must be awaited first!");
20749 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
20750 // debug statements here
20752 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
20754 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
20755 if(!isWasmInitialized) {
20756 throw new Error("initializeWasm() must be awaited first!");
20758 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
20759 return nativeResponseValue;
20761 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
20763 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
20764 if(!isWasmInitialized) {
20765 throw new Error("initializeWasm() must be awaited first!");
20767 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
20768 return nativeResponseValue;
20770 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
20772 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
20773 if(!isWasmInitialized) {
20774 throw new Error("initializeWasm() must be awaited first!");
20776 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
20777 return nativeResponseValue;
20779 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
20781 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
20782 if(!isWasmInitialized) {
20783 throw new Error("initializeWasm() must be awaited first!");
20785 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
20786 // debug statements here
20788 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
20790 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20791 if(!isWasmInitialized) {
20792 throw new Error("initializeWasm() must be awaited first!");
20794 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
20795 return nativeResponseValue;
20797 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
20799 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
20800 if(!isWasmInitialized) {
20801 throw new Error("initializeWasm() must be awaited first!");
20803 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
20804 return nativeResponseValue;
20806 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
20808 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
20809 if(!isWasmInitialized) {
20810 throw new Error("initializeWasm() must be awaited first!");
20812 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
20813 return nativeResponseValue;
20815 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
20817 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
20818 if(!isWasmInitialized) {
20819 throw new Error("initializeWasm() must be awaited first!");
20821 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
20822 return nativeResponseValue;
20824 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
20826 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
20827 if(!isWasmInitialized) {
20828 throw new Error("initializeWasm() must be awaited first!");
20830 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
20831 return nativeResponseValue;
20833 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
20835 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
20836 if(!isWasmInitialized) {
20837 throw new Error("initializeWasm() must be awaited first!");
20839 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
20840 // debug statements here
20842 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
20844 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20845 if(!isWasmInitialized) {
20846 throw new Error("initializeWasm() must be awaited first!");
20848 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
20849 return nativeResponseValue;
20851 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
20853 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
20854 if(!isWasmInitialized) {
20855 throw new Error("initializeWasm() must be awaited first!");
20857 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
20858 return nativeResponseValue;
20860 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
20862 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
20863 if(!isWasmInitialized) {
20864 throw new Error("initializeWasm() must be awaited first!");
20866 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
20867 return nativeResponseValue;
20869 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
20871 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
20872 if(!isWasmInitialized) {
20873 throw new Error("initializeWasm() must be awaited first!");
20875 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
20876 return nativeResponseValue;
20878 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
20880 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
20881 if(!isWasmInitialized) {
20882 throw new Error("initializeWasm() must be awaited first!");
20884 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
20885 return nativeResponseValue;
20887 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
20889 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
20890 if(!isWasmInitialized) {
20891 throw new Error("initializeWasm() must be awaited first!");
20893 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
20894 // debug statements here
20896 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
20898 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20899 if(!isWasmInitialized) {
20900 throw new Error("initializeWasm() must be awaited first!");
20902 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
20903 return nativeResponseValue;
20905 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
20907 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
20908 if(!isWasmInitialized) {
20909 throw new Error("initializeWasm() must be awaited first!");
20911 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
20912 return nativeResponseValue;
20914 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
20916 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
20917 if(!isWasmInitialized) {
20918 throw new Error("initializeWasm() must be awaited first!");
20920 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
20921 return nativeResponseValue;
20923 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
20925 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
20926 if(!isWasmInitialized) {
20927 throw new Error("initializeWasm() must be awaited first!");
20929 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
20930 return nativeResponseValue;
20932 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
20934 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
20935 if(!isWasmInitialized) {
20936 throw new Error("initializeWasm() must be awaited first!");
20938 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
20939 return nativeResponseValue;
20941 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
20943 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
20944 if(!isWasmInitialized) {
20945 throw new Error("initializeWasm() must be awaited first!");
20947 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
20948 // debug statements here
20950 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
20952 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20953 if(!isWasmInitialized) {
20954 throw new Error("initializeWasm() must be awaited first!");
20956 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
20957 return nativeResponseValue;
20959 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
20961 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
20962 if(!isWasmInitialized) {
20963 throw new Error("initializeWasm() must be awaited first!");
20965 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
20966 return nativeResponseValue;
20968 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
20970 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
20971 if(!isWasmInitialized) {
20972 throw new Error("initializeWasm() must be awaited first!");
20974 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
20975 return nativeResponseValue;
20977 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
20979 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
20980 if(!isWasmInitialized) {
20981 throw new Error("initializeWasm() must be awaited first!");
20983 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
20984 return nativeResponseValue;
20986 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
20988 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
20989 if(!isWasmInitialized) {
20990 throw new Error("initializeWasm() must be awaited first!");
20992 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
20993 return nativeResponseValue;
20995 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
20997 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
20998 if(!isWasmInitialized) {
20999 throw new Error("initializeWasm() must be awaited first!");
21001 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
21002 // debug statements here
21004 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
21006 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21007 if(!isWasmInitialized) {
21008 throw new Error("initializeWasm() must be awaited first!");
21010 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
21011 return nativeResponseValue;
21013 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
21015 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
21016 if(!isWasmInitialized) {
21017 throw new Error("initializeWasm() must be awaited first!");
21019 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
21020 return nativeResponseValue;
21022 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
21024 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
21025 if(!isWasmInitialized) {
21026 throw new Error("initializeWasm() must be awaited first!");
21028 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
21029 return nativeResponseValue;
21031 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
21033 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
21034 if(!isWasmInitialized) {
21035 throw new Error("initializeWasm() must be awaited first!");
21037 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
21038 return nativeResponseValue;
21040 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
21042 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
21043 if(!isWasmInitialized) {
21044 throw new Error("initializeWasm() must be awaited first!");
21046 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
21047 return nativeResponseValue;
21049 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
21051 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
21052 if(!isWasmInitialized) {
21053 throw new Error("initializeWasm() must be awaited first!");
21055 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
21056 // debug statements here
21058 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
21060 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21061 if(!isWasmInitialized) {
21062 throw new Error("initializeWasm() must be awaited first!");
21064 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
21065 return nativeResponseValue;
21067 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
21069 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
21070 if(!isWasmInitialized) {
21071 throw new Error("initializeWasm() must be awaited first!");
21073 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
21074 return nativeResponseValue;
21076 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
21078 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
21079 if(!isWasmInitialized) {
21080 throw new Error("initializeWasm() must be awaited first!");
21082 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
21083 return nativeResponseValue;
21085 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
21087 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
21088 if(!isWasmInitialized) {
21089 throw new Error("initializeWasm() must be awaited first!");
21091 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
21092 return nativeResponseValue;
21094 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
21096 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
21097 if(!isWasmInitialized) {
21098 throw new Error("initializeWasm() must be awaited first!");
21100 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
21101 return nativeResponseValue;
21103 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
21105 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
21106 if(!isWasmInitialized) {
21107 throw new Error("initializeWasm() must be awaited first!");
21109 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
21110 // debug statements here
21112 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
21114 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21115 if(!isWasmInitialized) {
21116 throw new Error("initializeWasm() must be awaited first!");
21118 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
21119 return nativeResponseValue;
21121 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
21123 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
21124 if(!isWasmInitialized) {
21125 throw new Error("initializeWasm() must be awaited first!");
21127 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
21128 return nativeResponseValue;
21130 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
21132 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
21133 if(!isWasmInitialized) {
21134 throw new Error("initializeWasm() must be awaited first!");
21136 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
21137 return nativeResponseValue;
21139 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
21141 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
21142 if(!isWasmInitialized) {
21143 throw new Error("initializeWasm() must be awaited first!");
21145 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
21146 return nativeResponseValue;
21148 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
21150 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
21151 if(!isWasmInitialized) {
21152 throw new Error("initializeWasm() must be awaited first!");
21154 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
21155 return nativeResponseValue;
21157 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
21159 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
21160 if(!isWasmInitialized) {
21161 throw new Error("initializeWasm() must be awaited first!");
21163 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
21164 // debug statements here
21166 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
21168 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21169 if(!isWasmInitialized) {
21170 throw new Error("initializeWasm() must be awaited first!");
21172 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
21173 return nativeResponseValue;
21175 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
21177 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
21178 if(!isWasmInitialized) {
21179 throw new Error("initializeWasm() must be awaited first!");
21181 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
21182 return nativeResponseValue;
21184 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
21186 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
21187 if(!isWasmInitialized) {
21188 throw new Error("initializeWasm() must be awaited first!");
21190 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
21191 return nativeResponseValue;
21193 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
21195 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
21196 if(!isWasmInitialized) {
21197 throw new Error("initializeWasm() must be awaited first!");
21199 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
21200 return nativeResponseValue;
21202 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
21204 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
21205 if(!isWasmInitialized) {
21206 throw new Error("initializeWasm() must be awaited first!");
21208 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
21209 return nativeResponseValue;
21211 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
21213 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
21214 if(!isWasmInitialized) {
21215 throw new Error("initializeWasm() must be awaited first!");
21217 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
21218 // debug statements here
21220 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
21222 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
21223 if(!isWasmInitialized) {
21224 throw new Error("initializeWasm() must be awaited first!");
21226 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
21227 return nativeResponseValue;
21229 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
21231 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
21232 if(!isWasmInitialized) {
21233 throw new Error("initializeWasm() must be awaited first!");
21235 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
21236 return nativeResponseValue;
21238 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
21240 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
21241 if(!isWasmInitialized) {
21242 throw new Error("initializeWasm() must be awaited first!");
21244 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
21245 return nativeResponseValue;
21247 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
21249 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
21250 if(!isWasmInitialized) {
21251 throw new Error("initializeWasm() must be awaited first!");
21253 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
21254 // debug statements here
21256 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
21258 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21259 if(!isWasmInitialized) {
21260 throw new Error("initializeWasm() must be awaited first!");
21262 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
21263 return nativeResponseValue;
21265 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
21267 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
21268 if(!isWasmInitialized) {
21269 throw new Error("initializeWasm() must be awaited first!");
21271 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
21272 return nativeResponseValue;
21274 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
21276 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
21277 if(!isWasmInitialized) {
21278 throw new Error("initializeWasm() must be awaited first!");
21280 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
21281 return nativeResponseValue;
21283 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
21285 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
21286 if(!isWasmInitialized) {
21287 throw new Error("initializeWasm() must be awaited first!");
21289 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
21290 return nativeResponseValue;
21292 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
21294 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
21295 if(!isWasmInitialized) {
21296 throw new Error("initializeWasm() must be awaited first!");
21298 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
21299 return nativeResponseValue;
21301 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
21303 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
21304 if(!isWasmInitialized) {
21305 throw new Error("initializeWasm() must be awaited first!");
21307 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
21308 // debug statements here
21310 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_ok(struct LDKCVec_ECDSASignatureZ o);
21312 export function CResult_CVec_ECDSASignatureZNoneZ_ok(o: number): bigint {
21313 if(!isWasmInitialized) {
21314 throw new Error("initializeWasm() must be awaited first!");
21316 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_ok(o);
21317 return nativeResponseValue;
21319 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_err(void);
21321 export function CResult_CVec_ECDSASignatureZNoneZ_err(): bigint {
21322 if(!isWasmInitialized) {
21323 throw new Error("initializeWasm() must be awaited first!");
21325 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_err();
21326 return nativeResponseValue;
21328 // bool CResult_CVec_ECDSASignatureZNoneZ_is_ok(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR o);
21330 export function CResult_CVec_ECDSASignatureZNoneZ_is_ok(o: bigint): boolean {
21331 if(!isWasmInitialized) {
21332 throw new Error("initializeWasm() must be awaited first!");
21334 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_is_ok(o);
21335 return nativeResponseValue;
21337 // void CResult_CVec_ECDSASignatureZNoneZ_free(struct LDKCResult_CVec_ECDSASignatureZNoneZ _res);
21339 export function CResult_CVec_ECDSASignatureZNoneZ_free(_res: bigint): void {
21340 if(!isWasmInitialized) {
21341 throw new Error("initializeWasm() must be awaited first!");
21343 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_free(_res);
21344 // debug statements here
21346 // uint64_t CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR arg);
21348 export function CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg: bigint): bigint {
21349 if(!isWasmInitialized) {
21350 throw new Error("initializeWasm() must be awaited first!");
21352 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg);
21353 return nativeResponseValue;
21355 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_clone(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR orig);
21357 export function CResult_CVec_ECDSASignatureZNoneZ_clone(orig: bigint): bigint {
21358 if(!isWasmInitialized) {
21359 throw new Error("initializeWasm() must be awaited first!");
21361 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone(orig);
21362 return nativeResponseValue;
21364 // struct LDKCOption_usizeZ COption_usizeZ_some(uintptr_t o);
21366 export function COption_usizeZ_some(o: number): bigint {
21367 if(!isWasmInitialized) {
21368 throw new Error("initializeWasm() must be awaited first!");
21370 const nativeResponseValue = wasm.TS_COption_usizeZ_some(o);
21371 return nativeResponseValue;
21373 // struct LDKCOption_usizeZ COption_usizeZ_none(void);
21375 export function COption_usizeZ_none(): bigint {
21376 if(!isWasmInitialized) {
21377 throw new Error("initializeWasm() must be awaited first!");
21379 const nativeResponseValue = wasm.TS_COption_usizeZ_none();
21380 return nativeResponseValue;
21382 // void COption_usizeZ_free(struct LDKCOption_usizeZ _res);
21384 export function COption_usizeZ_free(_res: bigint): void {
21385 if(!isWasmInitialized) {
21386 throw new Error("initializeWasm() must be awaited first!");
21388 const nativeResponseValue = wasm.TS_COption_usizeZ_free(_res);
21389 // debug statements here
21391 // uint64_t COption_usizeZ_clone_ptr(LDKCOption_usizeZ *NONNULL_PTR arg);
21393 export function COption_usizeZ_clone_ptr(arg: bigint): bigint {
21394 if(!isWasmInitialized) {
21395 throw new Error("initializeWasm() must be awaited first!");
21397 const nativeResponseValue = wasm.TS_COption_usizeZ_clone_ptr(arg);
21398 return nativeResponseValue;
21400 // struct LDKCOption_usizeZ COption_usizeZ_clone(const struct LDKCOption_usizeZ *NONNULL_PTR orig);
21402 export function COption_usizeZ_clone(orig: bigint): bigint {
21403 if(!isWasmInitialized) {
21404 throw new Error("initializeWasm() must be awaited first!");
21406 const nativeResponseValue = wasm.TS_COption_usizeZ_clone(orig);
21407 return nativeResponseValue;
21409 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
21411 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
21412 if(!isWasmInitialized) {
21413 throw new Error("initializeWasm() must be awaited first!");
21415 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
21416 return nativeResponseValue;
21418 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
21420 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
21421 if(!isWasmInitialized) {
21422 throw new Error("initializeWasm() must be awaited first!");
21424 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
21425 return nativeResponseValue;
21427 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
21429 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
21430 if(!isWasmInitialized) {
21431 throw new Error("initializeWasm() must be awaited first!");
21433 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
21434 return nativeResponseValue;
21436 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
21438 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
21439 if(!isWasmInitialized) {
21440 throw new Error("initializeWasm() must be awaited first!");
21442 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
21443 // debug statements here
21445 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
21447 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21448 if(!isWasmInitialized) {
21449 throw new Error("initializeWasm() must be awaited first!");
21451 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
21452 return nativeResponseValue;
21454 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
21456 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
21457 if(!isWasmInitialized) {
21458 throw new Error("initializeWasm() must be awaited first!");
21460 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
21461 return nativeResponseValue;
21463 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
21465 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
21466 if(!isWasmInitialized) {
21467 throw new Error("initializeWasm() must be awaited first!");
21469 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
21470 return nativeResponseValue;
21472 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
21474 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
21475 if(!isWasmInitialized) {
21476 throw new Error("initializeWasm() must be awaited first!");
21478 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
21479 return nativeResponseValue;
21481 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
21483 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
21484 if(!isWasmInitialized) {
21485 throw new Error("initializeWasm() must be awaited first!");
21487 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
21488 return nativeResponseValue;
21490 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
21492 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
21493 if(!isWasmInitialized) {
21494 throw new Error("initializeWasm() must be awaited first!");
21496 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
21497 // debug statements here
21499 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
21501 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
21502 if(!isWasmInitialized) {
21503 throw new Error("initializeWasm() must be awaited first!");
21505 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
21506 return nativeResponseValue;
21508 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
21510 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
21511 if(!isWasmInitialized) {
21512 throw new Error("initializeWasm() must be awaited first!");
21514 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
21515 return nativeResponseValue;
21517 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
21519 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
21520 if(!isWasmInitialized) {
21521 throw new Error("initializeWasm() must be awaited first!");
21523 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
21524 return nativeResponseValue;
21526 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
21528 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
21529 if(!isWasmInitialized) {
21530 throw new Error("initializeWasm() must be awaited first!");
21532 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
21533 return nativeResponseValue;
21535 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
21537 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
21538 if(!isWasmInitialized) {
21539 throw new Error("initializeWasm() must be awaited first!");
21541 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
21542 return nativeResponseValue;
21544 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
21546 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
21547 if(!isWasmInitialized) {
21548 throw new Error("initializeWasm() must be awaited first!");
21550 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
21551 // debug statements here
21553 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
21555 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21556 if(!isWasmInitialized) {
21557 throw new Error("initializeWasm() must be awaited first!");
21559 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
21560 return nativeResponseValue;
21562 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
21564 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
21565 if(!isWasmInitialized) {
21566 throw new Error("initializeWasm() must be awaited first!");
21568 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
21569 return nativeResponseValue;
21571 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_ok(struct LDKClaimedHTLC o);
21573 export function CResult_ClaimedHTLCDecodeErrorZ_ok(o: bigint): bigint {
21574 if(!isWasmInitialized) {
21575 throw new Error("initializeWasm() must be awaited first!");
21577 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_ok(o);
21578 return nativeResponseValue;
21580 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
21582 export function CResult_ClaimedHTLCDecodeErrorZ_err(e: bigint): bigint {
21583 if(!isWasmInitialized) {
21584 throw new Error("initializeWasm() must be awaited first!");
21586 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_err(e);
21587 return nativeResponseValue;
21589 // bool CResult_ClaimedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR o);
21591 export function CResult_ClaimedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
21592 if(!isWasmInitialized) {
21593 throw new Error("initializeWasm() must be awaited first!");
21595 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_is_ok(o);
21596 return nativeResponseValue;
21598 // void CResult_ClaimedHTLCDecodeErrorZ_free(struct LDKCResult_ClaimedHTLCDecodeErrorZ _res);
21600 export function CResult_ClaimedHTLCDecodeErrorZ_free(_res: bigint): void {
21601 if(!isWasmInitialized) {
21602 throw new Error("initializeWasm() must be awaited first!");
21604 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_free(_res);
21605 // debug statements here
21607 // uint64_t CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR arg);
21609 export function CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21610 if(!isWasmInitialized) {
21611 throw new Error("initializeWasm() must be awaited first!");
21613 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg);
21614 return nativeResponseValue;
21616 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_clone(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR orig);
21618 export function CResult_ClaimedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
21619 if(!isWasmInitialized) {
21620 throw new Error("initializeWasm() must be awaited first!");
21622 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone(orig);
21623 return nativeResponseValue;
21625 // struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
21627 export function COption_PathFailureZ_some(o: bigint): bigint {
21628 if(!isWasmInitialized) {
21629 throw new Error("initializeWasm() must be awaited first!");
21631 const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
21632 return nativeResponseValue;
21634 // struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
21636 export function COption_PathFailureZ_none(): bigint {
21637 if(!isWasmInitialized) {
21638 throw new Error("initializeWasm() must be awaited first!");
21640 const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
21641 return nativeResponseValue;
21643 // void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
21645 export function COption_PathFailureZ_free(_res: bigint): void {
21646 if(!isWasmInitialized) {
21647 throw new Error("initializeWasm() must be awaited first!");
21649 const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
21650 // debug statements here
21652 // uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
21654 export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
21655 if(!isWasmInitialized) {
21656 throw new Error("initializeWasm() must be awaited first!");
21658 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
21659 return nativeResponseValue;
21661 // struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
21663 export function COption_PathFailureZ_clone(orig: bigint): bigint {
21664 if(!isWasmInitialized) {
21665 throw new Error("initializeWasm() must be awaited first!");
21667 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
21668 return nativeResponseValue;
21670 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
21672 export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
21673 if(!isWasmInitialized) {
21674 throw new Error("initializeWasm() must be awaited first!");
21676 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
21677 return nativeResponseValue;
21679 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
21681 export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
21682 if(!isWasmInitialized) {
21683 throw new Error("initializeWasm() must be awaited first!");
21685 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
21686 return nativeResponseValue;
21688 // bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
21690 export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
21691 if(!isWasmInitialized) {
21692 throw new Error("initializeWasm() must be awaited first!");
21694 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
21695 return nativeResponseValue;
21697 // void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
21699 export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
21700 if(!isWasmInitialized) {
21701 throw new Error("initializeWasm() must be awaited first!");
21703 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
21704 // debug statements here
21706 // uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
21708 export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21709 if(!isWasmInitialized) {
21710 throw new Error("initializeWasm() must be awaited first!");
21712 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
21713 return nativeResponseValue;
21715 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
21717 export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
21718 if(!isWasmInitialized) {
21719 throw new Error("initializeWasm() must be awaited first!");
21721 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
21722 return nativeResponseValue;
21724 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
21726 export function COption_ClosureReasonZ_some(o: bigint): bigint {
21727 if(!isWasmInitialized) {
21728 throw new Error("initializeWasm() must be awaited first!");
21730 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
21731 return nativeResponseValue;
21733 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
21735 export function COption_ClosureReasonZ_none(): bigint {
21736 if(!isWasmInitialized) {
21737 throw new Error("initializeWasm() must be awaited first!");
21739 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
21740 return nativeResponseValue;
21742 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
21744 export function COption_ClosureReasonZ_free(_res: bigint): void {
21745 if(!isWasmInitialized) {
21746 throw new Error("initializeWasm() must be awaited first!");
21748 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
21749 // debug statements here
21751 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
21753 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
21754 if(!isWasmInitialized) {
21755 throw new Error("initializeWasm() must be awaited first!");
21757 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
21758 return nativeResponseValue;
21760 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
21762 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
21763 if(!isWasmInitialized) {
21764 throw new Error("initializeWasm() must be awaited first!");
21766 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
21767 return nativeResponseValue;
21769 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
21771 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
21772 if(!isWasmInitialized) {
21773 throw new Error("initializeWasm() must be awaited first!");
21775 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
21776 return nativeResponseValue;
21778 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
21780 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
21781 if(!isWasmInitialized) {
21782 throw new Error("initializeWasm() must be awaited first!");
21784 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
21785 return nativeResponseValue;
21787 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
21789 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
21790 if(!isWasmInitialized) {
21791 throw new Error("initializeWasm() must be awaited first!");
21793 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
21794 return nativeResponseValue;
21796 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
21798 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
21799 if(!isWasmInitialized) {
21800 throw new Error("initializeWasm() must be awaited first!");
21802 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
21803 // debug statements here
21805 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
21807 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21808 if(!isWasmInitialized) {
21809 throw new Error("initializeWasm() must be awaited first!");
21811 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
21812 return nativeResponseValue;
21814 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
21816 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
21817 if(!isWasmInitialized) {
21818 throw new Error("initializeWasm() must be awaited first!");
21820 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
21821 return nativeResponseValue;
21823 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
21825 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
21826 if(!isWasmInitialized) {
21827 throw new Error("initializeWasm() must be awaited first!");
21829 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
21830 return nativeResponseValue;
21832 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
21834 export function COption_HTLCDestinationZ_none(): bigint {
21835 if(!isWasmInitialized) {
21836 throw new Error("initializeWasm() must be awaited first!");
21838 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
21839 return nativeResponseValue;
21841 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
21843 export function COption_HTLCDestinationZ_free(_res: bigint): void {
21844 if(!isWasmInitialized) {
21845 throw new Error("initializeWasm() must be awaited first!");
21847 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
21848 // debug statements here
21850 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
21852 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
21853 if(!isWasmInitialized) {
21854 throw new Error("initializeWasm() must be awaited first!");
21856 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
21857 return nativeResponseValue;
21859 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
21861 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
21862 if(!isWasmInitialized) {
21863 throw new Error("initializeWasm() must be awaited first!");
21865 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
21866 return nativeResponseValue;
21868 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
21870 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
21871 if(!isWasmInitialized) {
21872 throw new Error("initializeWasm() must be awaited first!");
21874 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
21875 return nativeResponseValue;
21877 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
21879 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
21880 if(!isWasmInitialized) {
21881 throw new Error("initializeWasm() must be awaited first!");
21883 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
21884 return nativeResponseValue;
21886 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
21888 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
21889 if(!isWasmInitialized) {
21890 throw new Error("initializeWasm() must be awaited first!");
21892 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
21893 return nativeResponseValue;
21895 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
21897 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
21898 if(!isWasmInitialized) {
21899 throw new Error("initializeWasm() must be awaited first!");
21901 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
21902 // debug statements here
21904 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
21906 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21907 if(!isWasmInitialized) {
21908 throw new Error("initializeWasm() must be awaited first!");
21910 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
21911 return nativeResponseValue;
21913 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
21915 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
21916 if(!isWasmInitialized) {
21917 throw new Error("initializeWasm() must be awaited first!");
21919 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
21920 return nativeResponseValue;
21922 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_ok(enum LDKPaymentFailureReason o);
21924 export function CResult_PaymentFailureReasonDecodeErrorZ_ok(o: PaymentFailureReason): bigint {
21925 if(!isWasmInitialized) {
21926 throw new Error("initializeWasm() must be awaited first!");
21928 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(o);
21929 return nativeResponseValue;
21931 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_err(struct LDKDecodeError e);
21933 export function CResult_PaymentFailureReasonDecodeErrorZ_err(e: bigint): bigint {
21934 if(!isWasmInitialized) {
21935 throw new Error("initializeWasm() must be awaited first!");
21937 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_err(e);
21938 return nativeResponseValue;
21940 // bool CResult_PaymentFailureReasonDecodeErrorZ_is_ok(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR o);
21942 export function CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o: bigint): boolean {
21943 if(!isWasmInitialized) {
21944 throw new Error("initializeWasm() must be awaited first!");
21946 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o);
21947 return nativeResponseValue;
21949 // void CResult_PaymentFailureReasonDecodeErrorZ_free(struct LDKCResult_PaymentFailureReasonDecodeErrorZ _res);
21951 export function CResult_PaymentFailureReasonDecodeErrorZ_free(_res: bigint): void {
21952 if(!isWasmInitialized) {
21953 throw new Error("initializeWasm() must be awaited first!");
21955 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_free(_res);
21956 // debug statements here
21958 // uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg);
21960 export function CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21961 if(!isWasmInitialized) {
21962 throw new Error("initializeWasm() must be awaited first!");
21964 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg);
21965 return nativeResponseValue;
21967 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_clone(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR orig);
21969 export function CResult_PaymentFailureReasonDecodeErrorZ_clone(orig: bigint): bigint {
21970 if(!isWasmInitialized) {
21971 throw new Error("initializeWasm() must be awaited first!");
21973 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(orig);
21974 return nativeResponseValue;
21976 // struct LDKCOption_U128Z COption_U128Z_some(struct LDKU128 o);
21978 export function COption_U128Z_some(o: number): bigint {
21979 if(!isWasmInitialized) {
21980 throw new Error("initializeWasm() must be awaited first!");
21982 const nativeResponseValue = wasm.TS_COption_U128Z_some(o);
21983 return nativeResponseValue;
21985 // struct LDKCOption_U128Z COption_U128Z_none(void);
21987 export function COption_U128Z_none(): bigint {
21988 if(!isWasmInitialized) {
21989 throw new Error("initializeWasm() must be awaited first!");
21991 const nativeResponseValue = wasm.TS_COption_U128Z_none();
21992 return nativeResponseValue;
21994 // void COption_U128Z_free(struct LDKCOption_U128Z _res);
21996 export function COption_U128Z_free(_res: bigint): void {
21997 if(!isWasmInitialized) {
21998 throw new Error("initializeWasm() must be awaited first!");
22000 const nativeResponseValue = wasm.TS_COption_U128Z_free(_res);
22001 // debug statements here
22003 // uint64_t COption_U128Z_clone_ptr(LDKCOption_U128Z *NONNULL_PTR arg);
22005 export function COption_U128Z_clone_ptr(arg: bigint): bigint {
22006 if(!isWasmInitialized) {
22007 throw new Error("initializeWasm() must be awaited first!");
22009 const nativeResponseValue = wasm.TS_COption_U128Z_clone_ptr(arg);
22010 return nativeResponseValue;
22012 // struct LDKCOption_U128Z COption_U128Z_clone(const struct LDKCOption_U128Z *NONNULL_PTR orig);
22014 export function COption_U128Z_clone(orig: bigint): bigint {
22015 if(!isWasmInitialized) {
22016 throw new Error("initializeWasm() must be awaited first!");
22018 const nativeResponseValue = wasm.TS_COption_U128Z_clone(orig);
22019 return nativeResponseValue;
22021 // void CVec_ClaimedHTLCZ_free(struct LDKCVec_ClaimedHTLCZ _res);
22023 export function CVec_ClaimedHTLCZ_free(_res: number): void {
22024 if(!isWasmInitialized) {
22025 throw new Error("initializeWasm() must be awaited first!");
22027 const nativeResponseValue = wasm.TS_CVec_ClaimedHTLCZ_free(_res);
22028 // debug statements here
22030 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_some(enum LDKPaymentFailureReason o);
22032 export function COption_PaymentFailureReasonZ_some(o: PaymentFailureReason): bigint {
22033 if(!isWasmInitialized) {
22034 throw new Error("initializeWasm() must be awaited first!");
22036 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_some(o);
22037 return nativeResponseValue;
22039 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_none(void);
22041 export function COption_PaymentFailureReasonZ_none(): bigint {
22042 if(!isWasmInitialized) {
22043 throw new Error("initializeWasm() must be awaited first!");
22045 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_none();
22046 return nativeResponseValue;
22048 // void COption_PaymentFailureReasonZ_free(struct LDKCOption_PaymentFailureReasonZ _res);
22050 export function COption_PaymentFailureReasonZ_free(_res: bigint): void {
22051 if(!isWasmInitialized) {
22052 throw new Error("initializeWasm() must be awaited first!");
22054 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_free(_res);
22055 // debug statements here
22057 // uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg);
22059 export function COption_PaymentFailureReasonZ_clone_ptr(arg: bigint): bigint {
22060 if(!isWasmInitialized) {
22061 throw new Error("initializeWasm() must be awaited first!");
22063 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone_ptr(arg);
22064 return nativeResponseValue;
22066 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_clone(const struct LDKCOption_PaymentFailureReasonZ *NONNULL_PTR orig);
22068 export function COption_PaymentFailureReasonZ_clone(orig: bigint): bigint {
22069 if(!isWasmInitialized) {
22070 throw new Error("initializeWasm() must be awaited first!");
22072 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone(orig);
22073 return nativeResponseValue;
22075 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
22077 export function COption_EventZ_some(o: bigint): bigint {
22078 if(!isWasmInitialized) {
22079 throw new Error("initializeWasm() must be awaited first!");
22081 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
22082 return nativeResponseValue;
22084 // struct LDKCOption_EventZ COption_EventZ_none(void);
22086 export function COption_EventZ_none(): bigint {
22087 if(!isWasmInitialized) {
22088 throw new Error("initializeWasm() must be awaited first!");
22090 const nativeResponseValue = wasm.TS_COption_EventZ_none();
22091 return nativeResponseValue;
22093 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
22095 export function COption_EventZ_free(_res: bigint): void {
22096 if(!isWasmInitialized) {
22097 throw new Error("initializeWasm() must be awaited first!");
22099 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
22100 // debug statements here
22102 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
22104 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
22105 if(!isWasmInitialized) {
22106 throw new Error("initializeWasm() must be awaited first!");
22108 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
22109 return nativeResponseValue;
22111 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
22113 export function COption_EventZ_clone(orig: bigint): bigint {
22114 if(!isWasmInitialized) {
22115 throw new Error("initializeWasm() must be awaited first!");
22117 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
22118 return nativeResponseValue;
22120 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
22122 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
22123 if(!isWasmInitialized) {
22124 throw new Error("initializeWasm() must be awaited first!");
22126 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
22127 return nativeResponseValue;
22129 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
22131 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
22132 if(!isWasmInitialized) {
22133 throw new Error("initializeWasm() must be awaited first!");
22135 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
22136 return nativeResponseValue;
22138 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
22140 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
22141 if(!isWasmInitialized) {
22142 throw new Error("initializeWasm() must be awaited first!");
22144 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
22145 return nativeResponseValue;
22147 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
22149 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
22150 if(!isWasmInitialized) {
22151 throw new Error("initializeWasm() must be awaited first!");
22153 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
22154 // debug statements here
22156 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
22158 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22159 if(!isWasmInitialized) {
22160 throw new Error("initializeWasm() must be awaited first!");
22162 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
22163 return nativeResponseValue;
22165 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
22167 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
22168 if(!isWasmInitialized) {
22169 throw new Error("initializeWasm() must be awaited first!");
22171 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
22172 return nativeResponseValue;
22174 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_ok(enum LDKSiPrefix o);
22176 export function CResult_SiPrefixBolt11ParseErrorZ_ok(o: SiPrefix): bigint {
22177 if(!isWasmInitialized) {
22178 throw new Error("initializeWasm() must be awaited first!");
22180 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_ok(o);
22181 return nativeResponseValue;
22183 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
22185 export function CResult_SiPrefixBolt11ParseErrorZ_err(e: bigint): bigint {
22186 if(!isWasmInitialized) {
22187 throw new Error("initializeWasm() must be awaited first!");
22189 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_err(e);
22190 return nativeResponseValue;
22192 // bool CResult_SiPrefixBolt11ParseErrorZ_is_ok(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR o);
22194 export function CResult_SiPrefixBolt11ParseErrorZ_is_ok(o: bigint): boolean {
22195 if(!isWasmInitialized) {
22196 throw new Error("initializeWasm() must be awaited first!");
22198 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok(o);
22199 return nativeResponseValue;
22201 // void CResult_SiPrefixBolt11ParseErrorZ_free(struct LDKCResult_SiPrefixBolt11ParseErrorZ _res);
22203 export function CResult_SiPrefixBolt11ParseErrorZ_free(_res: bigint): void {
22204 if(!isWasmInitialized) {
22205 throw new Error("initializeWasm() must be awaited first!");
22207 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_free(_res);
22208 // debug statements here
22210 // uint64_t CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR arg);
22212 export function CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
22213 if(!isWasmInitialized) {
22214 throw new Error("initializeWasm() must be awaited first!");
22216 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg);
22217 return nativeResponseValue;
22219 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_clone(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR orig);
22221 export function CResult_SiPrefixBolt11ParseErrorZ_clone(orig: bigint): bigint {
22222 if(!isWasmInitialized) {
22223 throw new Error("initializeWasm() must be awaited first!");
22225 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone(orig);
22226 return nativeResponseValue;
22228 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(struct LDKBolt11Invoice o);
22230 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
22231 if(!isWasmInitialized) {
22232 throw new Error("initializeWasm() must be awaited first!");
22234 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o);
22235 return nativeResponseValue;
22237 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
22239 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
22240 if(!isWasmInitialized) {
22241 throw new Error("initializeWasm() must be awaited first!");
22243 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e);
22244 return nativeResponseValue;
22246 // bool CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
22248 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
22249 if(!isWasmInitialized) {
22250 throw new Error("initializeWasm() must be awaited first!");
22252 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o);
22253 return nativeResponseValue;
22255 // void CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ _res);
22257 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
22258 if(!isWasmInitialized) {
22259 throw new Error("initializeWasm() must be awaited first!");
22261 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res);
22262 // debug statements here
22264 // uint64_t CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
22266 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
22267 if(!isWasmInitialized) {
22268 throw new Error("initializeWasm() must be awaited first!");
22270 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
22271 return nativeResponseValue;
22273 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
22275 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
22276 if(!isWasmInitialized) {
22277 throw new Error("initializeWasm() must be awaited first!");
22279 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig);
22280 return nativeResponseValue;
22282 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(struct LDKSignedRawBolt11Invoice o);
22284 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o: bigint): bigint {
22285 if(!isWasmInitialized) {
22286 throw new Error("initializeWasm() must be awaited first!");
22288 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o);
22289 return nativeResponseValue;
22291 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
22293 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e: bigint): bigint {
22294 if(!isWasmInitialized) {
22295 throw new Error("initializeWasm() must be awaited first!");
22297 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e);
22298 return nativeResponseValue;
22300 // bool CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR o);
22302 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o: bigint): boolean {
22303 if(!isWasmInitialized) {
22304 throw new Error("initializeWasm() must be awaited first!");
22306 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o);
22307 return nativeResponseValue;
22309 // void CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ _res);
22311 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res: bigint): void {
22312 if(!isWasmInitialized) {
22313 throw new Error("initializeWasm() must be awaited first!");
22315 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res);
22316 // debug statements here
22318 // uint64_t CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR arg);
22320 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
22321 if(!isWasmInitialized) {
22322 throw new Error("initializeWasm() must be awaited first!");
22324 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg);
22325 return nativeResponseValue;
22327 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR orig);
22329 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig: bigint): bigint {
22330 if(!isWasmInitialized) {
22331 throw new Error("initializeWasm() must be awaited first!");
22333 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig);
22334 return nativeResponseValue;
22336 // uint64_t C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR arg);
22338 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
22339 if(!isWasmInitialized) {
22340 throw new Error("initializeWasm() must be awaited first!");
22342 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg);
22343 return nativeResponseValue;
22345 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR orig);
22347 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig: bigint): bigint {
22348 if(!isWasmInitialized) {
22349 throw new Error("initializeWasm() must be awaited first!");
22351 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig);
22352 return nativeResponseValue;
22354 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(struct LDKRawBolt11Invoice a, struct LDKThirtyTwoBytes b, struct LDKBolt11InvoiceSignature c);
22356 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
22357 if(!isWasmInitialized) {
22358 throw new Error("initializeWasm() must be awaited first!");
22360 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a, b, c);
22361 return nativeResponseValue;
22363 // void C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ _res);
22365 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res: bigint): void {
22366 if(!isWasmInitialized) {
22367 throw new Error("initializeWasm() must be awaited first!");
22369 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res);
22370 // debug statements here
22372 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_ok(struct LDKPayeePubKey o);
22374 export function CResult_PayeePubKeySecp256k1ErrorZ_ok(o: bigint): bigint {
22375 if(!isWasmInitialized) {
22376 throw new Error("initializeWasm() must be awaited first!");
22378 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_ok(o);
22379 return nativeResponseValue;
22381 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
22383 export function CResult_PayeePubKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
22384 if(!isWasmInitialized) {
22385 throw new Error("initializeWasm() must be awaited first!");
22387 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_err(e);
22388 return nativeResponseValue;
22390 // bool CResult_PayeePubKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR o);
22392 export function CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
22393 if(!isWasmInitialized) {
22394 throw new Error("initializeWasm() must be awaited first!");
22396 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o);
22397 return nativeResponseValue;
22399 // void CResult_PayeePubKeySecp256k1ErrorZ_free(struct LDKCResult_PayeePubKeySecp256k1ErrorZ _res);
22401 export function CResult_PayeePubKeySecp256k1ErrorZ_free(_res: bigint): void {
22402 if(!isWasmInitialized) {
22403 throw new Error("initializeWasm() must be awaited first!");
22405 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_free(_res);
22406 // debug statements here
22408 // uint64_t CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR arg);
22410 export function CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
22411 if(!isWasmInitialized) {
22412 throw new Error("initializeWasm() must be awaited first!");
22414 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg);
22415 return nativeResponseValue;
22417 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_clone(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR orig);
22419 export function CResult_PayeePubKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
22420 if(!isWasmInitialized) {
22421 throw new Error("initializeWasm() must be awaited first!");
22423 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone(orig);
22424 return nativeResponseValue;
22426 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
22428 export function CVec_PrivateRouteZ_free(_res: number): void {
22429 if(!isWasmInitialized) {
22430 throw new Error("initializeWasm() must be awaited first!");
22432 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
22433 // debug statements here
22435 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
22437 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
22438 if(!isWasmInitialized) {
22439 throw new Error("initializeWasm() must be awaited first!");
22441 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
22442 return nativeResponseValue;
22444 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
22446 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
22447 if(!isWasmInitialized) {
22448 throw new Error("initializeWasm() must be awaited first!");
22450 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
22451 return nativeResponseValue;
22453 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
22455 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
22456 if(!isWasmInitialized) {
22457 throw new Error("initializeWasm() must be awaited first!");
22459 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
22460 return nativeResponseValue;
22462 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
22464 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
22465 if(!isWasmInitialized) {
22466 throw new Error("initializeWasm() must be awaited first!");
22468 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
22469 // debug statements here
22471 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
22473 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
22474 if(!isWasmInitialized) {
22475 throw new Error("initializeWasm() must be awaited first!");
22477 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
22478 return nativeResponseValue;
22480 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
22482 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
22483 if(!isWasmInitialized) {
22484 throw new Error("initializeWasm() must be awaited first!");
22486 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
22487 return nativeResponseValue;
22489 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_ok(void);
22491 export function CResult_NoneBolt11SemanticErrorZ_ok(): bigint {
22492 if(!isWasmInitialized) {
22493 throw new Error("initializeWasm() must be awaited first!");
22495 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_ok();
22496 return nativeResponseValue;
22498 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
22500 export function CResult_NoneBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
22501 if(!isWasmInitialized) {
22502 throw new Error("initializeWasm() must be awaited first!");
22504 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_err(e);
22505 return nativeResponseValue;
22507 // bool CResult_NoneBolt11SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR o);
22509 export function CResult_NoneBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
22510 if(!isWasmInitialized) {
22511 throw new Error("initializeWasm() must be awaited first!");
22513 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_is_ok(o);
22514 return nativeResponseValue;
22516 // void CResult_NoneBolt11SemanticErrorZ_free(struct LDKCResult_NoneBolt11SemanticErrorZ _res);
22518 export function CResult_NoneBolt11SemanticErrorZ_free(_res: bigint): void {
22519 if(!isWasmInitialized) {
22520 throw new Error("initializeWasm() must be awaited first!");
22522 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_free(_res);
22523 // debug statements here
22525 // uint64_t CResult_NoneBolt11SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR arg);
22527 export function CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
22528 if(!isWasmInitialized) {
22529 throw new Error("initializeWasm() must be awaited first!");
22531 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg);
22532 return nativeResponseValue;
22534 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_clone(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR orig);
22536 export function CResult_NoneBolt11SemanticErrorZ_clone(orig: bigint): bigint {
22537 if(!isWasmInitialized) {
22538 throw new Error("initializeWasm() must be awaited first!");
22540 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone(orig);
22541 return nativeResponseValue;
22543 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(struct LDKBolt11Invoice o);
22545 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o: bigint): bigint {
22546 if(!isWasmInitialized) {
22547 throw new Error("initializeWasm() must be awaited first!");
22549 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o);
22550 return nativeResponseValue;
22552 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
22554 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
22555 if(!isWasmInitialized) {
22556 throw new Error("initializeWasm() must be awaited first!");
22558 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e);
22559 return nativeResponseValue;
22561 // bool CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR o);
22563 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
22564 if(!isWasmInitialized) {
22565 throw new Error("initializeWasm() must be awaited first!");
22567 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o);
22568 return nativeResponseValue;
22570 // void CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ _res);
22572 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res: bigint): void {
22573 if(!isWasmInitialized) {
22574 throw new Error("initializeWasm() must be awaited first!");
22576 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res);
22577 // debug statements here
22579 // uint64_t CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR arg);
22581 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
22582 if(!isWasmInitialized) {
22583 throw new Error("initializeWasm() must be awaited first!");
22585 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg);
22586 return nativeResponseValue;
22588 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR orig);
22590 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig: bigint): bigint {
22591 if(!isWasmInitialized) {
22592 throw new Error("initializeWasm() must be awaited first!");
22594 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig);
22595 return nativeResponseValue;
22597 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
22599 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
22600 if(!isWasmInitialized) {
22601 throw new Error("initializeWasm() must be awaited first!");
22603 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
22604 return nativeResponseValue;
22606 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
22608 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
22609 if(!isWasmInitialized) {
22610 throw new Error("initializeWasm() must be awaited first!");
22612 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
22613 return nativeResponseValue;
22615 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
22617 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
22618 if(!isWasmInitialized) {
22619 throw new Error("initializeWasm() must be awaited first!");
22621 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
22622 return nativeResponseValue;
22624 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
22626 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
22627 if(!isWasmInitialized) {
22628 throw new Error("initializeWasm() must be awaited first!");
22630 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
22631 // debug statements here
22633 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
22635 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
22636 if(!isWasmInitialized) {
22637 throw new Error("initializeWasm() must be awaited first!");
22639 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
22640 return nativeResponseValue;
22642 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
22644 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
22645 if(!isWasmInitialized) {
22646 throw new Error("initializeWasm() must be awaited first!");
22648 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
22649 return nativeResponseValue;
22651 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
22653 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
22654 if(!isWasmInitialized) {
22655 throw new Error("initializeWasm() must be awaited first!");
22657 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
22658 return nativeResponseValue;
22660 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
22662 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
22663 if(!isWasmInitialized) {
22664 throw new Error("initializeWasm() must be awaited first!");
22666 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
22667 return nativeResponseValue;
22669 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
22671 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
22672 if(!isWasmInitialized) {
22673 throw new Error("initializeWasm() must be awaited first!");
22675 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
22676 return nativeResponseValue;
22678 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
22680 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
22681 if(!isWasmInitialized) {
22682 throw new Error("initializeWasm() must be awaited first!");
22684 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
22685 // debug statements here
22687 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
22689 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
22690 if(!isWasmInitialized) {
22691 throw new Error("initializeWasm() must be awaited first!");
22693 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
22694 return nativeResponseValue;
22696 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
22698 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
22699 if(!isWasmInitialized) {
22700 throw new Error("initializeWasm() must be awaited first!");
22702 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
22703 return nativeResponseValue;
22705 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
22707 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
22708 if(!isWasmInitialized) {
22709 throw new Error("initializeWasm() must be awaited first!");
22711 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
22712 return nativeResponseValue;
22714 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
22716 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
22717 if(!isWasmInitialized) {
22718 throw new Error("initializeWasm() must be awaited first!");
22720 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
22721 return nativeResponseValue;
22723 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
22725 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
22726 if(!isWasmInitialized) {
22727 throw new Error("initializeWasm() must be awaited first!");
22729 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
22730 return nativeResponseValue;
22732 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
22734 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
22735 if(!isWasmInitialized) {
22736 throw new Error("initializeWasm() must be awaited first!");
22738 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
22739 // debug statements here
22741 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
22743 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22744 if(!isWasmInitialized) {
22745 throw new Error("initializeWasm() must be awaited first!");
22747 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
22748 return nativeResponseValue;
22750 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
22752 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
22753 if(!isWasmInitialized) {
22754 throw new Error("initializeWasm() must be awaited first!");
22756 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
22757 return nativeResponseValue;
22759 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_ok(struct LDKBigSize o);
22761 export function CResult_BigSizeDecodeErrorZ_ok(o: bigint): bigint {
22762 if(!isWasmInitialized) {
22763 throw new Error("initializeWasm() must be awaited first!");
22765 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_ok(o);
22766 return nativeResponseValue;
22768 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_err(struct LDKDecodeError e);
22770 export function CResult_BigSizeDecodeErrorZ_err(e: bigint): bigint {
22771 if(!isWasmInitialized) {
22772 throw new Error("initializeWasm() must be awaited first!");
22774 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_err(e);
22775 return nativeResponseValue;
22777 // bool CResult_BigSizeDecodeErrorZ_is_ok(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR o);
22779 export function CResult_BigSizeDecodeErrorZ_is_ok(o: bigint): boolean {
22780 if(!isWasmInitialized) {
22781 throw new Error("initializeWasm() must be awaited first!");
22783 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_is_ok(o);
22784 return nativeResponseValue;
22786 // void CResult_BigSizeDecodeErrorZ_free(struct LDKCResult_BigSizeDecodeErrorZ _res);
22788 export function CResult_BigSizeDecodeErrorZ_free(_res: bigint): void {
22789 if(!isWasmInitialized) {
22790 throw new Error("initializeWasm() must be awaited first!");
22792 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_free(_res);
22793 // debug statements here
22795 // uint64_t CResult_BigSizeDecodeErrorZ_clone_ptr(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR arg);
22797 export function CResult_BigSizeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22798 if(!isWasmInitialized) {
22799 throw new Error("initializeWasm() must be awaited first!");
22801 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone_ptr(arg);
22802 return nativeResponseValue;
22804 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_clone(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR orig);
22806 export function CResult_BigSizeDecodeErrorZ_clone(orig: bigint): bigint {
22807 if(!isWasmInitialized) {
22808 throw new Error("initializeWasm() must be awaited first!");
22810 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone(orig);
22811 return nativeResponseValue;
22813 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_ok(struct LDKHostname o);
22815 export function CResult_HostnameDecodeErrorZ_ok(o: bigint): bigint {
22816 if(!isWasmInitialized) {
22817 throw new Error("initializeWasm() must be awaited first!");
22819 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_ok(o);
22820 return nativeResponseValue;
22822 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_err(struct LDKDecodeError e);
22824 export function CResult_HostnameDecodeErrorZ_err(e: bigint): bigint {
22825 if(!isWasmInitialized) {
22826 throw new Error("initializeWasm() must be awaited first!");
22828 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_err(e);
22829 return nativeResponseValue;
22831 // bool CResult_HostnameDecodeErrorZ_is_ok(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR o);
22833 export function CResult_HostnameDecodeErrorZ_is_ok(o: bigint): boolean {
22834 if(!isWasmInitialized) {
22835 throw new Error("initializeWasm() must be awaited first!");
22837 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_is_ok(o);
22838 return nativeResponseValue;
22840 // void CResult_HostnameDecodeErrorZ_free(struct LDKCResult_HostnameDecodeErrorZ _res);
22842 export function CResult_HostnameDecodeErrorZ_free(_res: bigint): void {
22843 if(!isWasmInitialized) {
22844 throw new Error("initializeWasm() must be awaited first!");
22846 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_free(_res);
22847 // debug statements here
22849 // uint64_t CResult_HostnameDecodeErrorZ_clone_ptr(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR arg);
22851 export function CResult_HostnameDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22852 if(!isWasmInitialized) {
22853 throw new Error("initializeWasm() must be awaited first!");
22855 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone_ptr(arg);
22856 return nativeResponseValue;
22858 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_clone(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR orig);
22860 export function CResult_HostnameDecodeErrorZ_clone(orig: bigint): bigint {
22861 if(!isWasmInitialized) {
22862 throw new Error("initializeWasm() must be awaited first!");
22864 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone(orig);
22865 return nativeResponseValue;
22867 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_ok(struct LDKTransactionU16LenLimited o);
22869 export function CResult_TransactionU16LenLimitedNoneZ_ok(o: bigint): bigint {
22870 if(!isWasmInitialized) {
22871 throw new Error("initializeWasm() must be awaited first!");
22873 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_ok(o);
22874 return nativeResponseValue;
22876 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_err(void);
22878 export function CResult_TransactionU16LenLimitedNoneZ_err(): bigint {
22879 if(!isWasmInitialized) {
22880 throw new Error("initializeWasm() must be awaited first!");
22882 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_err();
22883 return nativeResponseValue;
22885 // bool CResult_TransactionU16LenLimitedNoneZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR o);
22887 export function CResult_TransactionU16LenLimitedNoneZ_is_ok(o: bigint): boolean {
22888 if(!isWasmInitialized) {
22889 throw new Error("initializeWasm() must be awaited first!");
22891 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_is_ok(o);
22892 return nativeResponseValue;
22894 // void CResult_TransactionU16LenLimitedNoneZ_free(struct LDKCResult_TransactionU16LenLimitedNoneZ _res);
22896 export function CResult_TransactionU16LenLimitedNoneZ_free(_res: bigint): void {
22897 if(!isWasmInitialized) {
22898 throw new Error("initializeWasm() must be awaited first!");
22900 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_free(_res);
22901 // debug statements here
22903 // uint64_t CResult_TransactionU16LenLimitedNoneZ_clone_ptr(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR arg);
22905 export function CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg: bigint): bigint {
22906 if(!isWasmInitialized) {
22907 throw new Error("initializeWasm() must be awaited first!");
22909 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg);
22910 return nativeResponseValue;
22912 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_clone(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR orig);
22914 export function CResult_TransactionU16LenLimitedNoneZ_clone(orig: bigint): bigint {
22915 if(!isWasmInitialized) {
22916 throw new Error("initializeWasm() must be awaited first!");
22918 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone(orig);
22919 return nativeResponseValue;
22921 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_ok(struct LDKTransactionU16LenLimited o);
22923 export function CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o: bigint): bigint {
22924 if(!isWasmInitialized) {
22925 throw new Error("initializeWasm() must be awaited first!");
22927 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o);
22928 return nativeResponseValue;
22930 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_err(struct LDKDecodeError e);
22932 export function CResult_TransactionU16LenLimitedDecodeErrorZ_err(e: bigint): bigint {
22933 if(!isWasmInitialized) {
22934 throw new Error("initializeWasm() must be awaited first!");
22936 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err(e);
22937 return nativeResponseValue;
22939 // bool CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR o);
22941 export function CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o: bigint): boolean {
22942 if(!isWasmInitialized) {
22943 throw new Error("initializeWasm() must be awaited first!");
22945 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o);
22946 return nativeResponseValue;
22948 // void CResult_TransactionU16LenLimitedDecodeErrorZ_free(struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ _res);
22950 export function CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res: bigint): void {
22951 if(!isWasmInitialized) {
22952 throw new Error("initializeWasm() must be awaited first!");
22954 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res);
22955 // debug statements here
22957 // uint64_t CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR arg);
22959 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22960 if(!isWasmInitialized) {
22961 throw new Error("initializeWasm() must be awaited first!");
22963 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg);
22964 return nativeResponseValue;
22966 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_clone(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR orig);
22968 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig: bigint): bigint {
22969 if(!isWasmInitialized) {
22970 throw new Error("initializeWasm() must be awaited first!");
22972 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig);
22973 return nativeResponseValue;
22975 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_ok(struct LDKUntrustedString o);
22977 export function CResult_UntrustedStringDecodeErrorZ_ok(o: bigint): bigint {
22978 if(!isWasmInitialized) {
22979 throw new Error("initializeWasm() must be awaited first!");
22981 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_ok(o);
22982 return nativeResponseValue;
22984 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_err(struct LDKDecodeError e);
22986 export function CResult_UntrustedStringDecodeErrorZ_err(e: bigint): bigint {
22987 if(!isWasmInitialized) {
22988 throw new Error("initializeWasm() must be awaited first!");
22990 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_err(e);
22991 return nativeResponseValue;
22993 // bool CResult_UntrustedStringDecodeErrorZ_is_ok(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR o);
22995 export function CResult_UntrustedStringDecodeErrorZ_is_ok(o: bigint): boolean {
22996 if(!isWasmInitialized) {
22997 throw new Error("initializeWasm() must be awaited first!");
22999 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_is_ok(o);
23000 return nativeResponseValue;
23002 // void CResult_UntrustedStringDecodeErrorZ_free(struct LDKCResult_UntrustedStringDecodeErrorZ _res);
23004 export function CResult_UntrustedStringDecodeErrorZ_free(_res: bigint): void {
23005 if(!isWasmInitialized) {
23006 throw new Error("initializeWasm() must be awaited first!");
23008 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_free(_res);
23009 // debug statements here
23011 // uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg);
23013 export function CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23014 if(!isWasmInitialized) {
23015 throw new Error("initializeWasm() must be awaited first!");
23017 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg);
23018 return nativeResponseValue;
23020 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_clone(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR orig);
23022 export function CResult_UntrustedStringDecodeErrorZ_clone(orig: bigint): bigint {
23023 if(!isWasmInitialized) {
23024 throw new Error("initializeWasm() must be awaited first!");
23026 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone(orig);
23027 return nativeResponseValue;
23029 // struct LDKCResult_ReceiveTlvsDecodeErrorZ CResult_ReceiveTlvsDecodeErrorZ_ok(struct LDKReceiveTlvs o);
23031 export function CResult_ReceiveTlvsDecodeErrorZ_ok(o: bigint): bigint {
23032 if(!isWasmInitialized) {
23033 throw new Error("initializeWasm() must be awaited first!");
23035 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_ok(o);
23036 return nativeResponseValue;
23038 // struct LDKCResult_ReceiveTlvsDecodeErrorZ CResult_ReceiveTlvsDecodeErrorZ_err(struct LDKDecodeError e);
23040 export function CResult_ReceiveTlvsDecodeErrorZ_err(e: bigint): bigint {
23041 if(!isWasmInitialized) {
23042 throw new Error("initializeWasm() must be awaited first!");
23044 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_err(e);
23045 return nativeResponseValue;
23047 // bool CResult_ReceiveTlvsDecodeErrorZ_is_ok(const struct LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR o);
23049 export function CResult_ReceiveTlvsDecodeErrorZ_is_ok(o: bigint): boolean {
23050 if(!isWasmInitialized) {
23051 throw new Error("initializeWasm() must be awaited first!");
23053 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_is_ok(o);
23054 return nativeResponseValue;
23056 // void CResult_ReceiveTlvsDecodeErrorZ_free(struct LDKCResult_ReceiveTlvsDecodeErrorZ _res);
23058 export function CResult_ReceiveTlvsDecodeErrorZ_free(_res: bigint): void {
23059 if(!isWasmInitialized) {
23060 throw new Error("initializeWasm() must be awaited first!");
23062 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_free(_res);
23063 // debug statements here
23065 // uint64_t CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR arg);
23067 export function CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23068 if(!isWasmInitialized) {
23069 throw new Error("initializeWasm() must be awaited first!");
23071 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(arg);
23072 return nativeResponseValue;
23074 // struct LDKCResult_ReceiveTlvsDecodeErrorZ CResult_ReceiveTlvsDecodeErrorZ_clone(const struct LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR orig);
23076 export function CResult_ReceiveTlvsDecodeErrorZ_clone(orig: bigint): bigint {
23077 if(!isWasmInitialized) {
23078 throw new Error("initializeWasm() must be awaited first!");
23080 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_clone(orig);
23081 return nativeResponseValue;
23083 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_ok(struct LDKPaymentRelay o);
23085 export function CResult_PaymentRelayDecodeErrorZ_ok(o: bigint): bigint {
23086 if(!isWasmInitialized) {
23087 throw new Error("initializeWasm() must be awaited first!");
23089 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_ok(o);
23090 return nativeResponseValue;
23092 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_err(struct LDKDecodeError e);
23094 export function CResult_PaymentRelayDecodeErrorZ_err(e: bigint): bigint {
23095 if(!isWasmInitialized) {
23096 throw new Error("initializeWasm() must be awaited first!");
23098 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_err(e);
23099 return nativeResponseValue;
23101 // bool CResult_PaymentRelayDecodeErrorZ_is_ok(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR o);
23103 export function CResult_PaymentRelayDecodeErrorZ_is_ok(o: bigint): boolean {
23104 if(!isWasmInitialized) {
23105 throw new Error("initializeWasm() must be awaited first!");
23107 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_is_ok(o);
23108 return nativeResponseValue;
23110 // void CResult_PaymentRelayDecodeErrorZ_free(struct LDKCResult_PaymentRelayDecodeErrorZ _res);
23112 export function CResult_PaymentRelayDecodeErrorZ_free(_res: bigint): void {
23113 if(!isWasmInitialized) {
23114 throw new Error("initializeWasm() must be awaited first!");
23116 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_free(_res);
23117 // debug statements here
23119 // uint64_t CResult_PaymentRelayDecodeErrorZ_clone_ptr(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR arg);
23121 export function CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23122 if(!isWasmInitialized) {
23123 throw new Error("initializeWasm() must be awaited first!");
23125 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg);
23126 return nativeResponseValue;
23128 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_clone(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR orig);
23130 export function CResult_PaymentRelayDecodeErrorZ_clone(orig: bigint): bigint {
23131 if(!isWasmInitialized) {
23132 throw new Error("initializeWasm() must be awaited first!");
23134 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone(orig);
23135 return nativeResponseValue;
23137 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_ok(struct LDKPaymentConstraints o);
23139 export function CResult_PaymentConstraintsDecodeErrorZ_ok(o: bigint): bigint {
23140 if(!isWasmInitialized) {
23141 throw new Error("initializeWasm() must be awaited first!");
23143 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_ok(o);
23144 return nativeResponseValue;
23146 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_err(struct LDKDecodeError e);
23148 export function CResult_PaymentConstraintsDecodeErrorZ_err(e: bigint): bigint {
23149 if(!isWasmInitialized) {
23150 throw new Error("initializeWasm() must be awaited first!");
23152 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_err(e);
23153 return nativeResponseValue;
23155 // bool CResult_PaymentConstraintsDecodeErrorZ_is_ok(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR o);
23157 export function CResult_PaymentConstraintsDecodeErrorZ_is_ok(o: bigint): boolean {
23158 if(!isWasmInitialized) {
23159 throw new Error("initializeWasm() must be awaited first!");
23161 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_is_ok(o);
23162 return nativeResponseValue;
23164 // void CResult_PaymentConstraintsDecodeErrorZ_free(struct LDKCResult_PaymentConstraintsDecodeErrorZ _res);
23166 export function CResult_PaymentConstraintsDecodeErrorZ_free(_res: bigint): void {
23167 if(!isWasmInitialized) {
23168 throw new Error("initializeWasm() must be awaited first!");
23170 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_free(_res);
23171 // debug statements here
23173 // uint64_t CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR arg);
23175 export function CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23176 if(!isWasmInitialized) {
23177 throw new Error("initializeWasm() must be awaited first!");
23179 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg);
23180 return nativeResponseValue;
23182 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_clone(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR orig);
23184 export function CResult_PaymentConstraintsDecodeErrorZ_clone(orig: bigint): bigint {
23185 if(!isWasmInitialized) {
23186 throw new Error("initializeWasm() must be awaited first!");
23188 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone(orig);
23189 return nativeResponseValue;
23191 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ CResult_ThirtyTwoBytesPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
23193 export function CResult_ThirtyTwoBytesPaymentErrorZ_ok(o: number): bigint {
23194 if(!isWasmInitialized) {
23195 throw new Error("initializeWasm() must be awaited first!");
23197 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_ok(o);
23198 return nativeResponseValue;
23200 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ CResult_ThirtyTwoBytesPaymentErrorZ_err(struct LDKPaymentError e);
23202 export function CResult_ThirtyTwoBytesPaymentErrorZ_err(e: bigint): bigint {
23203 if(!isWasmInitialized) {
23204 throw new Error("initializeWasm() must be awaited first!");
23206 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_err(e);
23207 return nativeResponseValue;
23209 // bool CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(const struct LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR o);
23211 export function CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(o: bigint): boolean {
23212 if(!isWasmInitialized) {
23213 throw new Error("initializeWasm() must be awaited first!");
23215 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(o);
23216 return nativeResponseValue;
23218 // void CResult_ThirtyTwoBytesPaymentErrorZ_free(struct LDKCResult_ThirtyTwoBytesPaymentErrorZ _res);
23220 export function CResult_ThirtyTwoBytesPaymentErrorZ_free(_res: bigint): void {
23221 if(!isWasmInitialized) {
23222 throw new Error("initializeWasm() must be awaited first!");
23224 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_free(_res);
23225 // debug statements here
23227 // uint64_t CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR arg);
23229 export function CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(arg: bigint): bigint {
23230 if(!isWasmInitialized) {
23231 throw new Error("initializeWasm() must be awaited first!");
23233 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(arg);
23234 return nativeResponseValue;
23236 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ CResult_ThirtyTwoBytesPaymentErrorZ_clone(const struct LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR orig);
23238 export function CResult_ThirtyTwoBytesPaymentErrorZ_clone(orig: bigint): bigint {
23239 if(!isWasmInitialized) {
23240 throw new Error("initializeWasm() must be awaited first!");
23242 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone(orig);
23243 return nativeResponseValue;
23245 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_ok(void);
23247 export function CResult_NonePaymentErrorZ_ok(): bigint {
23248 if(!isWasmInitialized) {
23249 throw new Error("initializeWasm() must be awaited first!");
23251 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_ok();
23252 return nativeResponseValue;
23254 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_err(struct LDKPaymentError e);
23256 export function CResult_NonePaymentErrorZ_err(e: bigint): bigint {
23257 if(!isWasmInitialized) {
23258 throw new Error("initializeWasm() must be awaited first!");
23260 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_err(e);
23261 return nativeResponseValue;
23263 // bool CResult_NonePaymentErrorZ_is_ok(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR o);
23265 export function CResult_NonePaymentErrorZ_is_ok(o: bigint): boolean {
23266 if(!isWasmInitialized) {
23267 throw new Error("initializeWasm() must be awaited first!");
23269 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_is_ok(o);
23270 return nativeResponseValue;
23272 // void CResult_NonePaymentErrorZ_free(struct LDKCResult_NonePaymentErrorZ _res);
23274 export function CResult_NonePaymentErrorZ_free(_res: bigint): void {
23275 if(!isWasmInitialized) {
23276 throw new Error("initializeWasm() must be awaited first!");
23278 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_free(_res);
23279 // debug statements here
23281 // uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg);
23283 export function CResult_NonePaymentErrorZ_clone_ptr(arg: bigint): bigint {
23284 if(!isWasmInitialized) {
23285 throw new Error("initializeWasm() must be awaited first!");
23287 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone_ptr(arg);
23288 return nativeResponseValue;
23290 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_clone(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR orig);
23292 export function CResult_NonePaymentErrorZ_clone(orig: bigint): bigint {
23293 if(!isWasmInitialized) {
23294 throw new Error("initializeWasm() must be awaited first!");
23296 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone(orig);
23297 return nativeResponseValue;
23299 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o);
23301 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(o: number): bigint {
23302 if(!isWasmInitialized) {
23303 throw new Error("initializeWasm() must be awaited first!");
23305 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(o);
23306 return nativeResponseValue;
23308 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(struct LDKProbingError e);
23310 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(e: bigint): bigint {
23311 if(!isWasmInitialized) {
23312 throw new Error("initializeWasm() must be awaited first!");
23314 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(e);
23315 return nativeResponseValue;
23317 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR o);
23319 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(o: bigint): boolean {
23320 if(!isWasmInitialized) {
23321 throw new Error("initializeWasm() must be awaited first!");
23323 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(o);
23324 return nativeResponseValue;
23326 // void CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ _res);
23328 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(_res: bigint): void {
23329 if(!isWasmInitialized) {
23330 throw new Error("initializeWasm() must be awaited first!");
23332 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(_res);
23333 // debug statements here
23335 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR arg);
23337 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(arg: bigint): bigint {
23338 if(!isWasmInitialized) {
23339 throw new Error("initializeWasm() must be awaited first!");
23341 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(arg);
23342 return nativeResponseValue;
23344 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR orig);
23346 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(orig: bigint): bigint {
23347 if(!isWasmInitialized) {
23348 throw new Error("initializeWasm() must be awaited first!");
23350 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(orig);
23351 return nativeResponseValue;
23353 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_ok(struct LDKStr o);
23355 export function CResult_StrSecp256k1ErrorZ_ok(o: number): bigint {
23356 if(!isWasmInitialized) {
23357 throw new Error("initializeWasm() must be awaited first!");
23359 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_ok(o);
23360 return nativeResponseValue;
23362 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
23364 export function CResult_StrSecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
23365 if(!isWasmInitialized) {
23366 throw new Error("initializeWasm() must be awaited first!");
23368 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_err(e);
23369 return nativeResponseValue;
23371 // bool CResult_StrSecp256k1ErrorZ_is_ok(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR o);
23373 export function CResult_StrSecp256k1ErrorZ_is_ok(o: bigint): boolean {
23374 if(!isWasmInitialized) {
23375 throw new Error("initializeWasm() must be awaited first!");
23377 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_is_ok(o);
23378 return nativeResponseValue;
23380 // void CResult_StrSecp256k1ErrorZ_free(struct LDKCResult_StrSecp256k1ErrorZ _res);
23382 export function CResult_StrSecp256k1ErrorZ_free(_res: bigint): void {
23383 if(!isWasmInitialized) {
23384 throw new Error("initializeWasm() must be awaited first!");
23386 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_free(_res);
23387 // debug statements here
23389 // uint64_t CResult_StrSecp256k1ErrorZ_clone_ptr(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR arg);
23391 export function CResult_StrSecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
23392 if(!isWasmInitialized) {
23393 throw new Error("initializeWasm() must be awaited first!");
23395 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone_ptr(arg);
23396 return nativeResponseValue;
23398 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_clone(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR orig);
23400 export function CResult_StrSecp256k1ErrorZ_clone(orig: bigint): bigint {
23401 if(!isWasmInitialized) {
23402 throw new Error("initializeWasm() must be awaited first!");
23404 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone(orig);
23405 return nativeResponseValue;
23407 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_ok(struct LDKTxOut o);
23409 export function CResult_TxOutUtxoLookupErrorZ_ok(o: bigint): bigint {
23410 if(!isWasmInitialized) {
23411 throw new Error("initializeWasm() must be awaited first!");
23413 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_ok(o);
23414 return nativeResponseValue;
23416 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_err(enum LDKUtxoLookupError e);
23418 export function CResult_TxOutUtxoLookupErrorZ_err(e: UtxoLookupError): bigint {
23419 if(!isWasmInitialized) {
23420 throw new Error("initializeWasm() must be awaited first!");
23422 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_err(e);
23423 return nativeResponseValue;
23425 // bool CResult_TxOutUtxoLookupErrorZ_is_ok(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR o);
23427 export function CResult_TxOutUtxoLookupErrorZ_is_ok(o: bigint): boolean {
23428 if(!isWasmInitialized) {
23429 throw new Error("initializeWasm() must be awaited first!");
23431 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_is_ok(o);
23432 return nativeResponseValue;
23434 // void CResult_TxOutUtxoLookupErrorZ_free(struct LDKCResult_TxOutUtxoLookupErrorZ _res);
23436 export function CResult_TxOutUtxoLookupErrorZ_free(_res: bigint): void {
23437 if(!isWasmInitialized) {
23438 throw new Error("initializeWasm() must be awaited first!");
23440 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_free(_res);
23441 // debug statements here
23443 // uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg);
23445 export function CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg: bigint): bigint {
23446 if(!isWasmInitialized) {
23447 throw new Error("initializeWasm() must be awaited first!");
23449 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg);
23450 return nativeResponseValue;
23452 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_clone(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR orig);
23454 export function CResult_TxOutUtxoLookupErrorZ_clone(orig: bigint): bigint {
23455 if(!isWasmInitialized) {
23456 throw new Error("initializeWasm() must be awaited first!");
23458 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone(orig);
23459 return nativeResponseValue;
23461 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_ok(struct LDKOnionMessagePath o);
23463 export function CResult_OnionMessagePathNoneZ_ok(o: bigint): bigint {
23464 if(!isWasmInitialized) {
23465 throw new Error("initializeWasm() must be awaited first!");
23467 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_ok(o);
23468 return nativeResponseValue;
23470 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_err(void);
23472 export function CResult_OnionMessagePathNoneZ_err(): bigint {
23473 if(!isWasmInitialized) {
23474 throw new Error("initializeWasm() must be awaited first!");
23476 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_err();
23477 return nativeResponseValue;
23479 // bool CResult_OnionMessagePathNoneZ_is_ok(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR o);
23481 export function CResult_OnionMessagePathNoneZ_is_ok(o: bigint): boolean {
23482 if(!isWasmInitialized) {
23483 throw new Error("initializeWasm() must be awaited first!");
23485 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_is_ok(o);
23486 return nativeResponseValue;
23488 // void CResult_OnionMessagePathNoneZ_free(struct LDKCResult_OnionMessagePathNoneZ _res);
23490 export function CResult_OnionMessagePathNoneZ_free(_res: bigint): void {
23491 if(!isWasmInitialized) {
23492 throw new Error("initializeWasm() must be awaited first!");
23494 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_free(_res);
23495 // debug statements here
23497 // uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg);
23499 export function CResult_OnionMessagePathNoneZ_clone_ptr(arg: bigint): bigint {
23500 if(!isWasmInitialized) {
23501 throw new Error("initializeWasm() must be awaited first!");
23503 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone_ptr(arg);
23504 return nativeResponseValue;
23506 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_clone(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR orig);
23508 export function CResult_OnionMessagePathNoneZ_clone(orig: bigint): bigint {
23509 if(!isWasmInitialized) {
23510 throw new Error("initializeWasm() must be awaited first!");
23512 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone(orig);
23513 return nativeResponseValue;
23515 // uint64_t C2Tuple_PublicKeyOnionMessageZ_clone_ptr(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR arg);
23517 export function C2Tuple_PublicKeyOnionMessageZ_clone_ptr(arg: bigint): bigint {
23518 if(!isWasmInitialized) {
23519 throw new Error("initializeWasm() must be awaited first!");
23521 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_clone_ptr(arg);
23522 return nativeResponseValue;
23524 // struct LDKC2Tuple_PublicKeyOnionMessageZ C2Tuple_PublicKeyOnionMessageZ_clone(const struct LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR orig);
23526 export function C2Tuple_PublicKeyOnionMessageZ_clone(orig: bigint): bigint {
23527 if(!isWasmInitialized) {
23528 throw new Error("initializeWasm() must be awaited first!");
23530 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_clone(orig);
23531 return nativeResponseValue;
23533 // struct LDKC2Tuple_PublicKeyOnionMessageZ C2Tuple_PublicKeyOnionMessageZ_new(struct LDKPublicKey a, struct LDKOnionMessage b);
23535 export function C2Tuple_PublicKeyOnionMessageZ_new(a: number, b: bigint): bigint {
23536 if(!isWasmInitialized) {
23537 throw new Error("initializeWasm() must be awaited first!");
23539 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_new(a, b);
23540 return nativeResponseValue;
23542 // void C2Tuple_PublicKeyOnionMessageZ_free(struct LDKC2Tuple_PublicKeyOnionMessageZ _res);
23544 export function C2Tuple_PublicKeyOnionMessageZ_free(_res: bigint): void {
23545 if(!isWasmInitialized) {
23546 throw new Error("initializeWasm() must be awaited first!");
23548 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_free(_res);
23549 // debug statements here
23551 // struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(struct LDKC2Tuple_PublicKeyOnionMessageZ o);
23553 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(o: bigint): bigint {
23554 if(!isWasmInitialized) {
23555 throw new Error("initializeWasm() must be awaited first!");
23557 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(o);
23558 return nativeResponseValue;
23560 // struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(struct LDKSendError e);
23562 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(e: bigint): bigint {
23563 if(!isWasmInitialized) {
23564 throw new Error("initializeWasm() must be awaited first!");
23566 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(e);
23567 return nativeResponseValue;
23569 // bool CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(const struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR o);
23571 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(o: bigint): boolean {
23572 if(!isWasmInitialized) {
23573 throw new Error("initializeWasm() must be awaited first!");
23575 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(o);
23576 return nativeResponseValue;
23578 // void CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ _res);
23580 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(_res: bigint): void {
23581 if(!isWasmInitialized) {
23582 throw new Error("initializeWasm() must be awaited first!");
23584 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(_res);
23585 // debug statements here
23587 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
23589 export function CResult_NoneSendErrorZ_ok(): bigint {
23590 if(!isWasmInitialized) {
23591 throw new Error("initializeWasm() must be awaited first!");
23593 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
23594 return nativeResponseValue;
23596 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
23598 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
23599 if(!isWasmInitialized) {
23600 throw new Error("initializeWasm() must be awaited first!");
23602 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
23603 return nativeResponseValue;
23605 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
23607 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
23608 if(!isWasmInitialized) {
23609 throw new Error("initializeWasm() must be awaited first!");
23611 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
23612 return nativeResponseValue;
23614 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
23616 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
23617 if(!isWasmInitialized) {
23618 throw new Error("initializeWasm() must be awaited first!");
23620 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
23621 // debug statements here
23623 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
23625 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
23626 if(!isWasmInitialized) {
23627 throw new Error("initializeWasm() must be awaited first!");
23629 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
23630 return nativeResponseValue;
23632 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
23634 export function CResult_BlindedPathNoneZ_err(): bigint {
23635 if(!isWasmInitialized) {
23636 throw new Error("initializeWasm() must be awaited first!");
23638 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
23639 return nativeResponseValue;
23641 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
23643 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
23644 if(!isWasmInitialized) {
23645 throw new Error("initializeWasm() must be awaited first!");
23647 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
23648 return nativeResponseValue;
23650 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
23652 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
23653 if(!isWasmInitialized) {
23654 throw new Error("initializeWasm() must be awaited first!");
23656 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
23657 // debug statements here
23659 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
23661 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
23662 if(!isWasmInitialized) {
23663 throw new Error("initializeWasm() must be awaited first!");
23665 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
23666 return nativeResponseValue;
23668 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
23670 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
23671 if(!isWasmInitialized) {
23672 throw new Error("initializeWasm() must be awaited first!");
23674 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
23675 return nativeResponseValue;
23677 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ o);
23679 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o: bigint): bigint {
23680 if(!isWasmInitialized) {
23681 throw new Error("initializeWasm() must be awaited first!");
23683 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o);
23684 return nativeResponseValue;
23686 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(void);
23688 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(): bigint {
23689 if(!isWasmInitialized) {
23690 throw new Error("initializeWasm() must be awaited first!");
23692 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err();
23693 return nativeResponseValue;
23695 // bool CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR o);
23697 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o: bigint): boolean {
23698 if(!isWasmInitialized) {
23699 throw new Error("initializeWasm() must be awaited first!");
23701 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o);
23702 return nativeResponseValue;
23704 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ _res);
23706 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res: bigint): void {
23707 if(!isWasmInitialized) {
23708 throw new Error("initializeWasm() must be awaited first!");
23710 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res);
23711 // debug statements here
23713 // uint64_t CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR arg);
23715 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg: bigint): bigint {
23716 if(!isWasmInitialized) {
23717 throw new Error("initializeWasm() must be awaited first!");
23719 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg);
23720 return nativeResponseValue;
23722 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR orig);
23724 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig: bigint): bigint {
23725 if(!isWasmInitialized) {
23726 throw new Error("initializeWasm() must be awaited first!");
23728 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig);
23729 return nativeResponseValue;
23731 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
23733 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
23734 if(!isWasmInitialized) {
23735 throw new Error("initializeWasm() must be awaited first!");
23737 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
23738 return nativeResponseValue;
23740 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
23742 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
23743 if(!isWasmInitialized) {
23744 throw new Error("initializeWasm() must be awaited first!");
23746 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
23747 return nativeResponseValue;
23749 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
23751 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
23752 if(!isWasmInitialized) {
23753 throw new Error("initializeWasm() must be awaited first!");
23755 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
23756 return nativeResponseValue;
23758 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
23760 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
23761 if(!isWasmInitialized) {
23762 throw new Error("initializeWasm() must be awaited first!");
23764 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
23765 // debug statements here
23767 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
23769 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23770 if(!isWasmInitialized) {
23771 throw new Error("initializeWasm() must be awaited first!");
23773 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
23774 return nativeResponseValue;
23776 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
23778 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
23779 if(!isWasmInitialized) {
23780 throw new Error("initializeWasm() must be awaited first!");
23782 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
23783 return nativeResponseValue;
23785 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
23787 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
23788 if(!isWasmInitialized) {
23789 throw new Error("initializeWasm() must be awaited first!");
23791 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
23792 return nativeResponseValue;
23794 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
23796 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
23797 if(!isWasmInitialized) {
23798 throw new Error("initializeWasm() must be awaited first!");
23800 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
23801 return nativeResponseValue;
23803 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
23805 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
23806 if(!isWasmInitialized) {
23807 throw new Error("initializeWasm() must be awaited first!");
23809 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
23810 return nativeResponseValue;
23812 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
23814 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
23815 if(!isWasmInitialized) {
23816 throw new Error("initializeWasm() must be awaited first!");
23818 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
23819 // debug statements here
23821 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
23823 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23824 if(!isWasmInitialized) {
23825 throw new Error("initializeWasm() must be awaited first!");
23827 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
23828 return nativeResponseValue;
23830 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
23832 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
23833 if(!isWasmInitialized) {
23834 throw new Error("initializeWasm() must be awaited first!");
23836 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
23837 return nativeResponseValue;
23839 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_ok(struct LDKInvoiceError o);
23841 export function CResult_InvoiceErrorDecodeErrorZ_ok(o: bigint): bigint {
23842 if(!isWasmInitialized) {
23843 throw new Error("initializeWasm() must be awaited first!");
23845 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_ok(o);
23846 return nativeResponseValue;
23848 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_err(struct LDKDecodeError e);
23850 export function CResult_InvoiceErrorDecodeErrorZ_err(e: bigint): bigint {
23851 if(!isWasmInitialized) {
23852 throw new Error("initializeWasm() must be awaited first!");
23854 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_err(e);
23855 return nativeResponseValue;
23857 // bool CResult_InvoiceErrorDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR o);
23859 export function CResult_InvoiceErrorDecodeErrorZ_is_ok(o: bigint): boolean {
23860 if(!isWasmInitialized) {
23861 throw new Error("initializeWasm() must be awaited first!");
23863 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_is_ok(o);
23864 return nativeResponseValue;
23866 // void CResult_InvoiceErrorDecodeErrorZ_free(struct LDKCResult_InvoiceErrorDecodeErrorZ _res);
23868 export function CResult_InvoiceErrorDecodeErrorZ_free(_res: bigint): void {
23869 if(!isWasmInitialized) {
23870 throw new Error("initializeWasm() must be awaited first!");
23872 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_free(_res);
23873 // debug statements here
23875 // uint64_t CResult_InvoiceErrorDecodeErrorZ_clone_ptr(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR arg);
23877 export function CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23878 if(!isWasmInitialized) {
23879 throw new Error("initializeWasm() must be awaited first!");
23881 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg);
23882 return nativeResponseValue;
23884 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_clone(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR orig);
23886 export function CResult_InvoiceErrorDecodeErrorZ_clone(orig: bigint): bigint {
23887 if(!isWasmInitialized) {
23888 throw new Error("initializeWasm() must be awaited first!");
23890 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone(orig);
23891 return nativeResponseValue;
23893 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
23895 export function COption_FilterZ_some(o: bigint): bigint {
23896 if(!isWasmInitialized) {
23897 throw new Error("initializeWasm() must be awaited first!");
23899 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
23900 return nativeResponseValue;
23902 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
23904 export function COption_FilterZ_none(): bigint {
23905 if(!isWasmInitialized) {
23906 throw new Error("initializeWasm() must be awaited first!");
23908 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
23909 return nativeResponseValue;
23911 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
23913 export function COption_FilterZ_free(_res: bigint): void {
23914 if(!isWasmInitialized) {
23915 throw new Error("initializeWasm() must be awaited first!");
23917 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
23918 // debug statements here
23920 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
23922 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
23923 if(!isWasmInitialized) {
23924 throw new Error("initializeWasm() must be awaited first!");
23926 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
23927 return nativeResponseValue;
23929 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
23931 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
23932 if(!isWasmInitialized) {
23933 throw new Error("initializeWasm() must be awaited first!");
23935 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
23936 return nativeResponseValue;
23938 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
23940 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
23941 if(!isWasmInitialized) {
23942 throw new Error("initializeWasm() must be awaited first!");
23944 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
23945 return nativeResponseValue;
23947 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
23949 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
23950 if(!isWasmInitialized) {
23951 throw new Error("initializeWasm() must be awaited first!");
23953 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
23954 // debug statements here
23956 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
23958 export function CVec_OutPointZ_free(_res: number): void {
23959 if(!isWasmInitialized) {
23960 throw new Error("initializeWasm() must be awaited first!");
23962 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
23963 // debug statements here
23965 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
23967 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
23968 if(!isWasmInitialized) {
23969 throw new Error("initializeWasm() must be awaited first!");
23971 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
23972 // debug statements here
23974 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
23976 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
23977 if(!isWasmInitialized) {
23978 throw new Error("initializeWasm() must be awaited first!");
23980 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
23981 return nativeResponseValue;
23983 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
23985 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
23986 if(!isWasmInitialized) {
23987 throw new Error("initializeWasm() must be awaited first!");
23989 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
23990 return nativeResponseValue;
23992 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
23994 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
23995 if(!isWasmInitialized) {
23996 throw new Error("initializeWasm() must be awaited first!");
23998 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
23999 return nativeResponseValue;
24001 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
24003 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
24004 if(!isWasmInitialized) {
24005 throw new Error("initializeWasm() must be awaited first!");
24007 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
24008 // debug statements here
24010 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
24012 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
24013 if(!isWasmInitialized) {
24014 throw new Error("initializeWasm() must be awaited first!");
24016 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
24017 // debug statements here
24019 // void APIError_free(struct LDKAPIError this_ptr);
24021 export function APIError_free(this_ptr: bigint): void {
24022 if(!isWasmInitialized) {
24023 throw new Error("initializeWasm() must be awaited first!");
24025 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
24026 // debug statements here
24028 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
24030 export function APIError_clone_ptr(arg: bigint): bigint {
24031 if(!isWasmInitialized) {
24032 throw new Error("initializeWasm() must be awaited first!");
24034 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
24035 return nativeResponseValue;
24037 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
24039 export function APIError_clone(orig: bigint): bigint {
24040 if(!isWasmInitialized) {
24041 throw new Error("initializeWasm() must be awaited first!");
24043 const nativeResponseValue = wasm.TS_APIError_clone(orig);
24044 return nativeResponseValue;
24046 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
24048 export function APIError_apimisuse_error(err: number): bigint {
24049 if(!isWasmInitialized) {
24050 throw new Error("initializeWasm() must be awaited first!");
24052 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
24053 return nativeResponseValue;
24055 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
24057 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
24058 if(!isWasmInitialized) {
24059 throw new Error("initializeWasm() must be awaited first!");
24061 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
24062 return nativeResponseValue;
24064 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
24066 export function APIError_invalid_route(err: number): bigint {
24067 if(!isWasmInitialized) {
24068 throw new Error("initializeWasm() must be awaited first!");
24070 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
24071 return nativeResponseValue;
24073 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
24075 export function APIError_channel_unavailable(err: number): bigint {
24076 if(!isWasmInitialized) {
24077 throw new Error("initializeWasm() must be awaited first!");
24079 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
24080 return nativeResponseValue;
24082 // struct LDKAPIError APIError_monitor_update_in_progress(void);
24084 export function APIError_monitor_update_in_progress(): bigint {
24085 if(!isWasmInitialized) {
24086 throw new Error("initializeWasm() must be awaited first!");
24088 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
24089 return nativeResponseValue;
24091 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
24093 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
24094 if(!isWasmInitialized) {
24095 throw new Error("initializeWasm() must be awaited first!");
24097 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
24098 return nativeResponseValue;
24100 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
24102 export function APIError_eq(a: bigint, b: bigint): boolean {
24103 if(!isWasmInitialized) {
24104 throw new Error("initializeWasm() must be awaited first!");
24106 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
24107 return nativeResponseValue;
24109 // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
24111 export function APIError_write(obj: bigint): number {
24112 if(!isWasmInitialized) {
24113 throw new Error("initializeWasm() must be awaited first!");
24115 const nativeResponseValue = wasm.TS_APIError_write(obj);
24116 return nativeResponseValue;
24118 // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
24120 export function APIError_read(ser: number): bigint {
24121 if(!isWasmInitialized) {
24122 throw new Error("initializeWasm() must be awaited first!");
24124 const nativeResponseValue = wasm.TS_APIError_read(ser);
24125 return nativeResponseValue;
24127 // void BigSize_free(struct LDKBigSize this_obj);
24129 export function BigSize_free(this_obj: bigint): void {
24130 if(!isWasmInitialized) {
24131 throw new Error("initializeWasm() must be awaited first!");
24133 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
24134 // debug statements here
24136 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
24138 export function BigSize_get_a(this_ptr: bigint): bigint {
24139 if(!isWasmInitialized) {
24140 throw new Error("initializeWasm() must be awaited first!");
24142 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
24143 return nativeResponseValue;
24145 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
24147 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
24148 if(!isWasmInitialized) {
24149 throw new Error("initializeWasm() must be awaited first!");
24151 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
24152 // debug statements here
24154 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
24156 export function BigSize_new(a_arg: bigint): bigint {
24157 if(!isWasmInitialized) {
24158 throw new Error("initializeWasm() must be awaited first!");
24160 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
24161 return nativeResponseValue;
24163 // uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg);
24165 export function BigSize_clone_ptr(arg: bigint): bigint {
24166 if(!isWasmInitialized) {
24167 throw new Error("initializeWasm() must be awaited first!");
24169 const nativeResponseValue = wasm.TS_BigSize_clone_ptr(arg);
24170 return nativeResponseValue;
24172 // struct LDKBigSize BigSize_clone(const struct LDKBigSize *NONNULL_PTR orig);
24174 export function BigSize_clone(orig: bigint): bigint {
24175 if(!isWasmInitialized) {
24176 throw new Error("initializeWasm() must be awaited first!");
24178 const nativeResponseValue = wasm.TS_BigSize_clone(orig);
24179 return nativeResponseValue;
24181 // uint64_t BigSize_hash(const struct LDKBigSize *NONNULL_PTR o);
24183 export function BigSize_hash(o: bigint): bigint {
24184 if(!isWasmInitialized) {
24185 throw new Error("initializeWasm() must be awaited first!");
24187 const nativeResponseValue = wasm.TS_BigSize_hash(o);
24188 return nativeResponseValue;
24190 // bool BigSize_eq(const struct LDKBigSize *NONNULL_PTR a, const struct LDKBigSize *NONNULL_PTR b);
24192 export function BigSize_eq(a: bigint, b: bigint): boolean {
24193 if(!isWasmInitialized) {
24194 throw new Error("initializeWasm() must be awaited first!");
24196 const nativeResponseValue = wasm.TS_BigSize_eq(a, b);
24197 return nativeResponseValue;
24199 // struct LDKCVec_u8Z BigSize_write(const struct LDKBigSize *NONNULL_PTR obj);
24201 export function BigSize_write(obj: bigint): number {
24202 if(!isWasmInitialized) {
24203 throw new Error("initializeWasm() must be awaited first!");
24205 const nativeResponseValue = wasm.TS_BigSize_write(obj);
24206 return nativeResponseValue;
24208 // struct LDKCResult_BigSizeDecodeErrorZ BigSize_read(struct LDKu8slice ser);
24210 export function BigSize_read(ser: number): bigint {
24211 if(!isWasmInitialized) {
24212 throw new Error("initializeWasm() must be awaited first!");
24214 const nativeResponseValue = wasm.TS_BigSize_read(ser);
24215 return nativeResponseValue;
24217 // void Hostname_free(struct LDKHostname this_obj);
24219 export function Hostname_free(this_obj: bigint): void {
24220 if(!isWasmInitialized) {
24221 throw new Error("initializeWasm() must be awaited first!");
24223 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
24224 // debug statements here
24226 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
24228 export function Hostname_clone_ptr(arg: bigint): bigint {
24229 if(!isWasmInitialized) {
24230 throw new Error("initializeWasm() must be awaited first!");
24232 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
24233 return nativeResponseValue;
24235 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
24237 export function Hostname_clone(orig: bigint): bigint {
24238 if(!isWasmInitialized) {
24239 throw new Error("initializeWasm() must be awaited first!");
24241 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
24242 return nativeResponseValue;
24244 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
24246 export function Hostname_eq(a: bigint, b: bigint): boolean {
24247 if(!isWasmInitialized) {
24248 throw new Error("initializeWasm() must be awaited first!");
24250 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
24251 return nativeResponseValue;
24253 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
24255 export function Hostname_len(this_arg: bigint): number {
24256 if(!isWasmInitialized) {
24257 throw new Error("initializeWasm() must be awaited first!");
24259 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
24260 return nativeResponseValue;
24262 // struct LDKCVec_u8Z Hostname_write(const struct LDKHostname *NONNULL_PTR obj);
24264 export function Hostname_write(obj: bigint): number {
24265 if(!isWasmInitialized) {
24266 throw new Error("initializeWasm() must be awaited first!");
24268 const nativeResponseValue = wasm.TS_Hostname_write(obj);
24269 return nativeResponseValue;
24271 // struct LDKCResult_HostnameDecodeErrorZ Hostname_read(struct LDKu8slice ser);
24273 export function Hostname_read(ser: number): bigint {
24274 if(!isWasmInitialized) {
24275 throw new Error("initializeWasm() must be awaited first!");
24277 const nativeResponseValue = wasm.TS_Hostname_read(ser);
24278 return nativeResponseValue;
24280 // void TransactionU16LenLimited_free(struct LDKTransactionU16LenLimited this_obj);
24282 export function TransactionU16LenLimited_free(this_obj: bigint): void {
24283 if(!isWasmInitialized) {
24284 throw new Error("initializeWasm() must be awaited first!");
24286 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_free(this_obj);
24287 // debug statements here
24289 // uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg);
24291 export function TransactionU16LenLimited_clone_ptr(arg: bigint): bigint {
24292 if(!isWasmInitialized) {
24293 throw new Error("initializeWasm() must be awaited first!");
24295 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone_ptr(arg);
24296 return nativeResponseValue;
24298 // struct LDKTransactionU16LenLimited TransactionU16LenLimited_clone(const struct LDKTransactionU16LenLimited *NONNULL_PTR orig);
24300 export function TransactionU16LenLimited_clone(orig: bigint): bigint {
24301 if(!isWasmInitialized) {
24302 throw new Error("initializeWasm() must be awaited first!");
24304 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone(orig);
24305 return nativeResponseValue;
24307 // bool TransactionU16LenLimited_eq(const struct LDKTransactionU16LenLimited *NONNULL_PTR a, const struct LDKTransactionU16LenLimited *NONNULL_PTR b);
24309 export function TransactionU16LenLimited_eq(a: bigint, b: bigint): boolean {
24310 if(!isWasmInitialized) {
24311 throw new Error("initializeWasm() must be awaited first!");
24313 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_eq(a, b);
24314 return nativeResponseValue;
24316 // MUST_USE_RES struct LDKCResult_TransactionU16LenLimitedNoneZ TransactionU16LenLimited_new(struct LDKTransaction transaction);
24318 export function TransactionU16LenLimited_new(transaction: number): bigint {
24319 if(!isWasmInitialized) {
24320 throw new Error("initializeWasm() must be awaited first!");
24322 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_new(transaction);
24323 return nativeResponseValue;
24325 // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_into_transaction(struct LDKTransactionU16LenLimited this_arg);
24327 export function TransactionU16LenLimited_into_transaction(this_arg: bigint): number {
24328 if(!isWasmInitialized) {
24329 throw new Error("initializeWasm() must be awaited first!");
24331 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_into_transaction(this_arg);
24332 return nativeResponseValue;
24334 // struct LDKCVec_u8Z TransactionU16LenLimited_write(const struct LDKTransactionU16LenLimited *NONNULL_PTR obj);
24336 export function TransactionU16LenLimited_write(obj: bigint): number {
24337 if(!isWasmInitialized) {
24338 throw new Error("initializeWasm() must be awaited first!");
24340 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_write(obj);
24341 return nativeResponseValue;
24343 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ TransactionU16LenLimited_read(struct LDKu8slice ser);
24345 export function TransactionU16LenLimited_read(ser: number): bigint {
24346 if(!isWasmInitialized) {
24347 throw new Error("initializeWasm() must be awaited first!");
24349 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_read(ser);
24350 return nativeResponseValue;
24352 // struct LDKCResult_StrSecp256k1ErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
24354 export function sign(msg: number, sk: number): bigint {
24355 if(!isWasmInitialized) {
24356 throw new Error("initializeWasm() must be awaited first!");
24358 const nativeResponseValue = wasm.TS_sign(msg, sk);
24359 return nativeResponseValue;
24361 // struct LDKCResult_PublicKeySecp256k1ErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
24363 export function recover_pk(msg: number, sig: number): bigint {
24364 if(!isWasmInitialized) {
24365 throw new Error("initializeWasm() must be awaited first!");
24367 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
24368 return nativeResponseValue;
24370 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
24372 export function verify(msg: number, sig: number, pk: number): boolean {
24373 if(!isWasmInitialized) {
24374 throw new Error("initializeWasm() must be awaited first!");
24376 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
24377 return nativeResponseValue;
24379 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
24381 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
24382 if(!isWasmInitialized) {
24383 throw new Error("initializeWasm() must be awaited first!");
24385 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
24386 return nativeResponseValue;
24388 // void KVStore_free(struct LDKKVStore this_ptr);
24390 export function KVStore_free(this_ptr: bigint): void {
24391 if(!isWasmInitialized) {
24392 throw new Error("initializeWasm() must be awaited first!");
24394 const nativeResponseValue = wasm.TS_KVStore_free(this_ptr);
24395 // debug statements here
24397 // void Persister_free(struct LDKPersister this_ptr);
24399 export function Persister_free(this_ptr: bigint): void {
24400 if(!isWasmInitialized) {
24401 throw new Error("initializeWasm() must be awaited first!");
24403 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
24404 // debug statements here
24406 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ read_channel_monitors(struct LDKKVStore kv_store, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
24408 export function read_channel_monitors(kv_store: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
24409 if(!isWasmInitialized) {
24410 throw new Error("initializeWasm() must be awaited first!");
24412 const nativeResponseValue = wasm.TS_read_channel_monitors(kv_store, entropy_source, signer_provider);
24413 return nativeResponseValue;
24415 // void MonitorUpdatingPersister_free(struct LDKMonitorUpdatingPersister this_obj);
24417 export function MonitorUpdatingPersister_free(this_obj: bigint): void {
24418 if(!isWasmInitialized) {
24419 throw new Error("initializeWasm() must be awaited first!");
24421 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_free(this_obj);
24422 // debug statements here
24424 // MUST_USE_RES struct LDKMonitorUpdatingPersister MonitorUpdatingPersister_new(struct LDKKVStore kv_store, struct LDKLogger logger, uint64_t maximum_pending_updates, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
24426 export function MonitorUpdatingPersister_new(kv_store: bigint, logger: bigint, maximum_pending_updates: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
24427 if(!isWasmInitialized) {
24428 throw new Error("initializeWasm() must be awaited first!");
24430 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_new(kv_store, logger, maximum_pending_updates, entropy_source, signer_provider);
24431 return nativeResponseValue;
24433 // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ MonitorUpdatingPersister_read_all_channel_monitors_with_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator);
24435 export function MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint): bigint {
24436 if(!isWasmInitialized) {
24437 throw new Error("initializeWasm() must be awaited first!");
24439 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg, broadcaster, fee_estimator);
24440 return nativeResponseValue;
24442 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ MonitorUpdatingPersister_read_channel_monitor_with_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, struct LDKStr monitor_key);
24444 export function MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, monitor_key: number): bigint {
24445 if(!isWasmInitialized) {
24446 throw new Error("initializeWasm() must be awaited first!");
24448 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg, broadcaster, fee_estimator, monitor_key);
24449 return nativeResponseValue;
24451 // MUST_USE_RES struct LDKCResult_NoneIOErrorZ MonitorUpdatingPersister_cleanup_stale_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, bool lazy);
24453 export function MonitorUpdatingPersister_cleanup_stale_updates(this_arg: bigint, lazy: boolean): bigint {
24454 if(!isWasmInitialized) {
24455 throw new Error("initializeWasm() must be awaited first!");
24457 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_cleanup_stale_updates(this_arg, lazy);
24458 return nativeResponseValue;
24460 // struct LDKPersist MonitorUpdatingPersister_as_Persist(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg);
24462 export function MonitorUpdatingPersister_as_Persist(this_arg: bigint): bigint {
24463 if(!isWasmInitialized) {
24464 throw new Error("initializeWasm() must be awaited first!");
24466 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_as_Persist(this_arg);
24467 return nativeResponseValue;
24469 // void UntrustedString_free(struct LDKUntrustedString this_obj);
24471 export function UntrustedString_free(this_obj: bigint): void {
24472 if(!isWasmInitialized) {
24473 throw new Error("initializeWasm() must be awaited first!");
24475 const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
24476 // debug statements here
24478 // struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
24480 export function UntrustedString_get_a(this_ptr: bigint): number {
24481 if(!isWasmInitialized) {
24482 throw new Error("initializeWasm() must be awaited first!");
24484 const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
24485 return nativeResponseValue;
24487 // void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
24489 export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
24490 if(!isWasmInitialized) {
24491 throw new Error("initializeWasm() must be awaited first!");
24493 const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
24494 // debug statements here
24496 // MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
24498 export function UntrustedString_new(a_arg: number): bigint {
24499 if(!isWasmInitialized) {
24500 throw new Error("initializeWasm() must be awaited first!");
24502 const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
24503 return nativeResponseValue;
24505 // uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
24507 export function UntrustedString_clone_ptr(arg: bigint): bigint {
24508 if(!isWasmInitialized) {
24509 throw new Error("initializeWasm() must be awaited first!");
24511 const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
24512 return nativeResponseValue;
24514 // struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
24516 export function UntrustedString_clone(orig: bigint): bigint {
24517 if(!isWasmInitialized) {
24518 throw new Error("initializeWasm() must be awaited first!");
24520 const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
24521 return nativeResponseValue;
24523 // bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
24525 export function UntrustedString_eq(a: bigint, b: bigint): boolean {
24526 if(!isWasmInitialized) {
24527 throw new Error("initializeWasm() must be awaited first!");
24529 const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
24530 return nativeResponseValue;
24532 // struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
24534 export function UntrustedString_write(obj: bigint): number {
24535 if(!isWasmInitialized) {
24536 throw new Error("initializeWasm() must be awaited first!");
24538 const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
24539 return nativeResponseValue;
24541 // struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
24543 export function UntrustedString_read(ser: number): bigint {
24544 if(!isWasmInitialized) {
24545 throw new Error("initializeWasm() must be awaited first!");
24547 const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
24548 return nativeResponseValue;
24550 // void PrintableString_free(struct LDKPrintableString this_obj);
24552 export function PrintableString_free(this_obj: bigint): void {
24553 if(!isWasmInitialized) {
24554 throw new Error("initializeWasm() must be awaited first!");
24556 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
24557 // debug statements here
24559 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
24561 export function PrintableString_get_a(this_ptr: bigint): number {
24562 if(!isWasmInitialized) {
24563 throw new Error("initializeWasm() must be awaited first!");
24565 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
24566 return nativeResponseValue;
24568 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
24570 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
24571 if(!isWasmInitialized) {
24572 throw new Error("initializeWasm() must be awaited first!");
24574 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
24575 // debug statements here
24577 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
24579 export function PrintableString_new(a_arg: number): bigint {
24580 if(!isWasmInitialized) {
24581 throw new Error("initializeWasm() must be awaited first!");
24583 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
24584 return nativeResponseValue;
24586 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
24588 export function FutureCallback_free(this_ptr: bigint): void {
24589 if(!isWasmInitialized) {
24590 throw new Error("initializeWasm() must be awaited first!");
24592 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
24593 // debug statements here
24595 // void Future_free(struct LDKFuture this_obj);
24597 export function Future_free(this_obj: bigint): void {
24598 if(!isWasmInitialized) {
24599 throw new Error("initializeWasm() must be awaited first!");
24601 const nativeResponseValue = wasm.TS_Future_free(this_obj);
24602 // debug statements here
24604 // uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg);
24606 export function Future_clone_ptr(arg: bigint): bigint {
24607 if(!isWasmInitialized) {
24608 throw new Error("initializeWasm() must be awaited first!");
24610 const nativeResponseValue = wasm.TS_Future_clone_ptr(arg);
24611 return nativeResponseValue;
24613 // struct LDKFuture Future_clone(const struct LDKFuture *NONNULL_PTR orig);
24615 export function Future_clone(orig: bigint): bigint {
24616 if(!isWasmInitialized) {
24617 throw new Error("initializeWasm() must be awaited first!");
24619 const nativeResponseValue = wasm.TS_Future_clone(orig);
24620 return nativeResponseValue;
24622 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
24624 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
24625 if(!isWasmInitialized) {
24626 throw new Error("initializeWasm() must be awaited first!");
24628 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
24629 // debug statements here
24631 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
24633 export function Level_clone(orig: bigint): Level {
24634 if(!isWasmInitialized) {
24635 throw new Error("initializeWasm() must be awaited first!");
24637 const nativeResponseValue = wasm.TS_Level_clone(orig);
24638 return nativeResponseValue;
24640 // enum LDKLevel Level_gossip(void);
24642 export function Level_gossip(): Level {
24643 if(!isWasmInitialized) {
24644 throw new Error("initializeWasm() must be awaited first!");
24646 const nativeResponseValue = wasm.TS_Level_gossip();
24647 return nativeResponseValue;
24649 // enum LDKLevel Level_trace(void);
24651 export function Level_trace(): Level {
24652 if(!isWasmInitialized) {
24653 throw new Error("initializeWasm() must be awaited first!");
24655 const nativeResponseValue = wasm.TS_Level_trace();
24656 return nativeResponseValue;
24658 // enum LDKLevel Level_debug(void);
24660 export function Level_debug(): Level {
24661 if(!isWasmInitialized) {
24662 throw new Error("initializeWasm() must be awaited first!");
24664 const nativeResponseValue = wasm.TS_Level_debug();
24665 return nativeResponseValue;
24667 // enum LDKLevel Level_info(void);
24669 export function Level_info(): Level {
24670 if(!isWasmInitialized) {
24671 throw new Error("initializeWasm() must be awaited first!");
24673 const nativeResponseValue = wasm.TS_Level_info();
24674 return nativeResponseValue;
24676 // enum LDKLevel Level_warn(void);
24678 export function Level_warn(): Level {
24679 if(!isWasmInitialized) {
24680 throw new Error("initializeWasm() must be awaited first!");
24682 const nativeResponseValue = wasm.TS_Level_warn();
24683 return nativeResponseValue;
24685 // enum LDKLevel Level_error(void);
24687 export function Level_error(): Level {
24688 if(!isWasmInitialized) {
24689 throw new Error("initializeWasm() must be awaited first!");
24691 const nativeResponseValue = wasm.TS_Level_error();
24692 return nativeResponseValue;
24694 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
24696 export function Level_eq(a: bigint, b: bigint): boolean {
24697 if(!isWasmInitialized) {
24698 throw new Error("initializeWasm() must be awaited first!");
24700 const nativeResponseValue = wasm.TS_Level_eq(a, b);
24701 return nativeResponseValue;
24703 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
24705 export function Level_hash(o: bigint): bigint {
24706 if(!isWasmInitialized) {
24707 throw new Error("initializeWasm() must be awaited first!");
24709 const nativeResponseValue = wasm.TS_Level_hash(o);
24710 return nativeResponseValue;
24712 // MUST_USE_RES enum LDKLevel Level_max(void);
24714 export function Level_max(): Level {
24715 if(!isWasmInitialized) {
24716 throw new Error("initializeWasm() must be awaited first!");
24718 const nativeResponseValue = wasm.TS_Level_max();
24719 return nativeResponseValue;
24721 // void Record_free(struct LDKRecord this_obj);
24723 export function Record_free(this_obj: bigint): void {
24724 if(!isWasmInitialized) {
24725 throw new Error("initializeWasm() must be awaited first!");
24727 const nativeResponseValue = wasm.TS_Record_free(this_obj);
24728 // debug statements here
24730 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
24732 export function Record_get_level(this_ptr: bigint): Level {
24733 if(!isWasmInitialized) {
24734 throw new Error("initializeWasm() must be awaited first!");
24736 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
24737 return nativeResponseValue;
24739 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
24741 export function Record_set_level(this_ptr: bigint, val: Level): void {
24742 if(!isWasmInitialized) {
24743 throw new Error("initializeWasm() must be awaited first!");
24745 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
24746 // debug statements here
24748 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
24750 export function Record_get_args(this_ptr: bigint): number {
24751 if(!isWasmInitialized) {
24752 throw new Error("initializeWasm() must be awaited first!");
24754 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
24755 return nativeResponseValue;
24757 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
24759 export function Record_set_args(this_ptr: bigint, val: number): void {
24760 if(!isWasmInitialized) {
24761 throw new Error("initializeWasm() must be awaited first!");
24763 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
24764 // debug statements here
24766 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
24768 export function Record_get_module_path(this_ptr: bigint): number {
24769 if(!isWasmInitialized) {
24770 throw new Error("initializeWasm() must be awaited first!");
24772 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
24773 return nativeResponseValue;
24775 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
24777 export function Record_set_module_path(this_ptr: bigint, val: number): void {
24778 if(!isWasmInitialized) {
24779 throw new Error("initializeWasm() must be awaited first!");
24781 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
24782 // debug statements here
24784 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
24786 export function Record_get_file(this_ptr: bigint): number {
24787 if(!isWasmInitialized) {
24788 throw new Error("initializeWasm() must be awaited first!");
24790 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
24791 return nativeResponseValue;
24793 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
24795 export function Record_set_file(this_ptr: bigint, val: number): void {
24796 if(!isWasmInitialized) {
24797 throw new Error("initializeWasm() must be awaited first!");
24799 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
24800 // debug statements here
24802 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
24804 export function Record_get_line(this_ptr: bigint): number {
24805 if(!isWasmInitialized) {
24806 throw new Error("initializeWasm() must be awaited first!");
24808 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
24809 return nativeResponseValue;
24811 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
24813 export function Record_set_line(this_ptr: bigint, val: number): void {
24814 if(!isWasmInitialized) {
24815 throw new Error("initializeWasm() must be awaited first!");
24817 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
24818 // debug statements here
24820 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
24822 export function Record_clone_ptr(arg: bigint): bigint {
24823 if(!isWasmInitialized) {
24824 throw new Error("initializeWasm() must be awaited first!");
24826 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
24827 return nativeResponseValue;
24829 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
24831 export function Record_clone(orig: bigint): bigint {
24832 if(!isWasmInitialized) {
24833 throw new Error("initializeWasm() must be awaited first!");
24835 const nativeResponseValue = wasm.TS_Record_clone(orig);
24836 return nativeResponseValue;
24838 // void Logger_free(struct LDKLogger this_ptr);
24840 export function Logger_free(this_ptr: bigint): void {
24841 if(!isWasmInitialized) {
24842 throw new Error("initializeWasm() must be awaited first!");
24844 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
24845 // debug statements here
24847 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
24849 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
24850 if(!isWasmInitialized) {
24851 throw new Error("initializeWasm() must be awaited first!");
24853 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
24854 // debug statements here
24856 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24858 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
24859 if(!isWasmInitialized) {
24860 throw new Error("initializeWasm() must be awaited first!");
24862 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
24863 return nativeResponseValue;
24865 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
24867 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
24868 if(!isWasmInitialized) {
24869 throw new Error("initializeWasm() must be awaited first!");
24871 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
24872 // debug statements here
24874 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24876 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
24877 if(!isWasmInitialized) {
24878 throw new Error("initializeWasm() must be awaited first!");
24880 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
24881 return nativeResponseValue;
24883 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
24885 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
24886 if(!isWasmInitialized) {
24887 throw new Error("initializeWasm() must be awaited first!");
24889 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
24890 // debug statements here
24892 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24894 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
24895 if(!isWasmInitialized) {
24896 throw new Error("initializeWasm() must be awaited first!");
24898 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
24899 return nativeResponseValue;
24901 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
24903 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
24904 if(!isWasmInitialized) {
24905 throw new Error("initializeWasm() must be awaited first!");
24907 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
24908 // debug statements here
24910 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24912 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
24913 if(!isWasmInitialized) {
24914 throw new Error("initializeWasm() must be awaited first!");
24916 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
24917 return nativeResponseValue;
24919 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
24921 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
24922 if(!isWasmInitialized) {
24923 throw new Error("initializeWasm() must be awaited first!");
24925 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
24926 // debug statements here
24928 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24930 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
24931 if(!isWasmInitialized) {
24932 throw new Error("initializeWasm() must be awaited first!");
24934 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
24935 return nativeResponseValue;
24937 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
24939 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
24940 if(!isWasmInitialized) {
24941 throw new Error("initializeWasm() must be awaited first!");
24943 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
24944 // debug statements here
24946 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24948 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
24949 if(!isWasmInitialized) {
24950 throw new Error("initializeWasm() must be awaited first!");
24952 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
24953 return nativeResponseValue;
24955 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
24957 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
24958 if(!isWasmInitialized) {
24959 throw new Error("initializeWasm() must be awaited first!");
24961 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
24962 // debug statements here
24964 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24966 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
24967 if(!isWasmInitialized) {
24968 throw new Error("initializeWasm() must be awaited first!");
24970 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
24971 return nativeResponseValue;
24973 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
24975 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
24976 if(!isWasmInitialized) {
24977 throw new Error("initializeWasm() must be awaited first!");
24979 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
24980 // debug statements here
24982 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
24984 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
24985 if(!isWasmInitialized) {
24986 throw new Error("initializeWasm() must be awaited first!");
24988 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
24989 return nativeResponseValue;
24991 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
24993 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
24994 if(!isWasmInitialized) {
24995 throw new Error("initializeWasm() must be awaited first!");
24997 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
24998 // debug statements here
25000 // bool ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25002 export function ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint): boolean {
25003 if(!isWasmInitialized) {
25004 throw new Error("initializeWasm() must be awaited first!");
25006 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr);
25007 return nativeResponseValue;
25009 // void ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
25011 export function ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint, val: boolean): void {
25012 if(!isWasmInitialized) {
25013 throw new Error("initializeWasm() must be awaited first!");
25015 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr, val);
25016 // debug statements here
25018 // uint16_t ChannelHandshakeConfig_get_our_max_accepted_htlcs(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25020 export function ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr: bigint): number {
25021 if(!isWasmInitialized) {
25022 throw new Error("initializeWasm() must be awaited first!");
25024 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr);
25025 return nativeResponseValue;
25027 // void ChannelHandshakeConfig_set_our_max_accepted_htlcs(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
25029 export function ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr: bigint, val: number): void {
25030 if(!isWasmInitialized) {
25031 throw new Error("initializeWasm() must be awaited first!");
25033 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr, val);
25034 // debug statements here
25036 // 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);
25038 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 {
25039 if(!isWasmInitialized) {
25040 throw new Error("initializeWasm() must be awaited first!");
25042 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);
25043 return nativeResponseValue;
25045 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
25047 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
25048 if(!isWasmInitialized) {
25049 throw new Error("initializeWasm() must be awaited first!");
25051 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
25052 return nativeResponseValue;
25054 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
25056 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
25057 if(!isWasmInitialized) {
25058 throw new Error("initializeWasm() must be awaited first!");
25060 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
25061 return nativeResponseValue;
25063 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
25065 export function ChannelHandshakeConfig_default(): bigint {
25066 if(!isWasmInitialized) {
25067 throw new Error("initializeWasm() must be awaited first!");
25069 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
25070 return nativeResponseValue;
25072 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
25074 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
25075 if(!isWasmInitialized) {
25076 throw new Error("initializeWasm() must be awaited first!");
25078 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
25079 // debug statements here
25081 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25083 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
25084 if(!isWasmInitialized) {
25085 throw new Error("initializeWasm() must be awaited first!");
25087 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
25088 return nativeResponseValue;
25090 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25092 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
25093 if(!isWasmInitialized) {
25094 throw new Error("initializeWasm() must be awaited first!");
25096 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
25097 // debug statements here
25099 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25101 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
25102 if(!isWasmInitialized) {
25103 throw new Error("initializeWasm() must be awaited first!");
25105 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
25106 return nativeResponseValue;
25108 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25110 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
25111 if(!isWasmInitialized) {
25112 throw new Error("initializeWasm() must be awaited first!");
25114 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
25115 // debug statements here
25117 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25119 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
25120 if(!isWasmInitialized) {
25121 throw new Error("initializeWasm() must be awaited first!");
25123 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
25124 return nativeResponseValue;
25126 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25128 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
25129 if(!isWasmInitialized) {
25130 throw new Error("initializeWasm() must be awaited first!");
25132 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
25133 // debug statements here
25135 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25137 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
25138 if(!isWasmInitialized) {
25139 throw new Error("initializeWasm() must be awaited first!");
25141 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
25142 return nativeResponseValue;
25144 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25146 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
25147 if(!isWasmInitialized) {
25148 throw new Error("initializeWasm() must be awaited first!");
25150 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
25151 // debug statements here
25153 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25155 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
25156 if(!isWasmInitialized) {
25157 throw new Error("initializeWasm() must be awaited first!");
25159 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
25160 return nativeResponseValue;
25162 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25164 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
25165 if(!isWasmInitialized) {
25166 throw new Error("initializeWasm() must be awaited first!");
25168 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
25169 // debug statements here
25171 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25173 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
25174 if(!isWasmInitialized) {
25175 throw new Error("initializeWasm() must be awaited first!");
25177 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
25178 return nativeResponseValue;
25180 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
25182 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
25183 if(!isWasmInitialized) {
25184 throw new Error("initializeWasm() must be awaited first!");
25186 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
25187 // debug statements here
25189 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25191 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
25192 if(!isWasmInitialized) {
25193 throw new Error("initializeWasm() must be awaited first!");
25195 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
25196 return nativeResponseValue;
25198 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
25200 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
25201 if(!isWasmInitialized) {
25202 throw new Error("initializeWasm() must be awaited first!");
25204 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
25205 // debug statements here
25207 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25209 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
25210 if(!isWasmInitialized) {
25211 throw new Error("initializeWasm() must be awaited first!");
25213 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
25214 return nativeResponseValue;
25216 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
25218 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
25219 if(!isWasmInitialized) {
25220 throw new Error("initializeWasm() must be awaited first!");
25222 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
25223 // debug statements here
25225 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25227 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
25228 if(!isWasmInitialized) {
25229 throw new Error("initializeWasm() must be awaited first!");
25231 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
25232 return nativeResponseValue;
25234 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
25236 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
25237 if(!isWasmInitialized) {
25238 throw new Error("initializeWasm() must be awaited first!");
25240 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
25241 // debug statements here
25243 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25245 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
25246 if(!isWasmInitialized) {
25247 throw new Error("initializeWasm() must be awaited first!");
25249 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
25250 return nativeResponseValue;
25252 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
25254 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
25255 if(!isWasmInitialized) {
25256 throw new Error("initializeWasm() must be awaited first!");
25258 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
25259 // debug statements here
25261 // 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);
25263 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 {
25264 if(!isWasmInitialized) {
25265 throw new Error("initializeWasm() must be awaited first!");
25267 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);
25268 return nativeResponseValue;
25270 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
25272 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
25273 if(!isWasmInitialized) {
25274 throw new Error("initializeWasm() must be awaited first!");
25276 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
25277 return nativeResponseValue;
25279 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
25281 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
25282 if(!isWasmInitialized) {
25283 throw new Error("initializeWasm() must be awaited first!");
25285 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
25286 return nativeResponseValue;
25288 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
25290 export function ChannelHandshakeLimits_default(): bigint {
25291 if(!isWasmInitialized) {
25292 throw new Error("initializeWasm() must be awaited first!");
25294 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
25295 return nativeResponseValue;
25297 // void MaxDustHTLCExposure_free(struct LDKMaxDustHTLCExposure this_ptr);
25299 export function MaxDustHTLCExposure_free(this_ptr: bigint): void {
25300 if(!isWasmInitialized) {
25301 throw new Error("initializeWasm() must be awaited first!");
25303 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_free(this_ptr);
25304 // debug statements here
25306 // uint64_t MaxDustHTLCExposure_clone_ptr(LDKMaxDustHTLCExposure *NONNULL_PTR arg);
25308 export function MaxDustHTLCExposure_clone_ptr(arg: bigint): bigint {
25309 if(!isWasmInitialized) {
25310 throw new Error("initializeWasm() must be awaited first!");
25312 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone_ptr(arg);
25313 return nativeResponseValue;
25315 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_clone(const struct LDKMaxDustHTLCExposure *NONNULL_PTR orig);
25317 export function MaxDustHTLCExposure_clone(orig: bigint): bigint {
25318 if(!isWasmInitialized) {
25319 throw new Error("initializeWasm() must be awaited first!");
25321 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone(orig);
25322 return nativeResponseValue;
25324 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fixed_limit_msat(uint64_t a);
25326 export function MaxDustHTLCExposure_fixed_limit_msat(a: bigint): bigint {
25327 if(!isWasmInitialized) {
25328 throw new Error("initializeWasm() must be awaited first!");
25330 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fixed_limit_msat(a);
25331 return nativeResponseValue;
25333 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fee_rate_multiplier(uint64_t a);
25335 export function MaxDustHTLCExposure_fee_rate_multiplier(a: bigint): bigint {
25336 if(!isWasmInitialized) {
25337 throw new Error("initializeWasm() must be awaited first!");
25339 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fee_rate_multiplier(a);
25340 return nativeResponseValue;
25342 // bool MaxDustHTLCExposure_eq(const struct LDKMaxDustHTLCExposure *NONNULL_PTR a, const struct LDKMaxDustHTLCExposure *NONNULL_PTR b);
25344 export function MaxDustHTLCExposure_eq(a: bigint, b: bigint): boolean {
25345 if(!isWasmInitialized) {
25346 throw new Error("initializeWasm() must be awaited first!");
25348 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_eq(a, b);
25349 return nativeResponseValue;
25351 // struct LDKCVec_u8Z MaxDustHTLCExposure_write(const struct LDKMaxDustHTLCExposure *NONNULL_PTR obj);
25353 export function MaxDustHTLCExposure_write(obj: bigint): number {
25354 if(!isWasmInitialized) {
25355 throw new Error("initializeWasm() must be awaited first!");
25357 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_write(obj);
25358 return nativeResponseValue;
25360 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ MaxDustHTLCExposure_read(struct LDKu8slice ser);
25362 export function MaxDustHTLCExposure_read(ser: number): bigint {
25363 if(!isWasmInitialized) {
25364 throw new Error("initializeWasm() must be awaited first!");
25366 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_read(ser);
25367 return nativeResponseValue;
25369 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
25371 export function ChannelConfig_free(this_obj: bigint): void {
25372 if(!isWasmInitialized) {
25373 throw new Error("initializeWasm() must be awaited first!");
25375 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
25376 // debug statements here
25378 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25380 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
25381 if(!isWasmInitialized) {
25382 throw new Error("initializeWasm() must be awaited first!");
25384 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
25385 return nativeResponseValue;
25387 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
25389 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
25390 if(!isWasmInitialized) {
25391 throw new Error("initializeWasm() must be awaited first!");
25393 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
25394 // debug statements here
25396 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25398 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
25399 if(!isWasmInitialized) {
25400 throw new Error("initializeWasm() must be awaited first!");
25402 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
25403 return nativeResponseValue;
25405 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
25407 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
25408 if(!isWasmInitialized) {
25409 throw new Error("initializeWasm() must be awaited first!");
25411 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
25412 // debug statements here
25414 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25416 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
25417 if(!isWasmInitialized) {
25418 throw new Error("initializeWasm() must be awaited first!");
25420 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
25421 return nativeResponseValue;
25423 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
25425 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
25426 if(!isWasmInitialized) {
25427 throw new Error("initializeWasm() must be awaited first!");
25429 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
25430 // debug statements here
25432 // struct LDKMaxDustHTLCExposure ChannelConfig_get_max_dust_htlc_exposure(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25434 export function ChannelConfig_get_max_dust_htlc_exposure(this_ptr: bigint): bigint {
25435 if(!isWasmInitialized) {
25436 throw new Error("initializeWasm() must be awaited first!");
25438 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure(this_ptr);
25439 return nativeResponseValue;
25441 // void ChannelConfig_set_max_dust_htlc_exposure(struct LDKChannelConfig *NONNULL_PTR this_ptr, struct LDKMaxDustHTLCExposure val);
25443 export function ChannelConfig_set_max_dust_htlc_exposure(this_ptr: bigint, val: bigint): void {
25444 if(!isWasmInitialized) {
25445 throw new Error("initializeWasm() must be awaited first!");
25447 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure(this_ptr, val);
25448 // debug statements here
25450 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25452 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
25453 if(!isWasmInitialized) {
25454 throw new Error("initializeWasm() must be awaited first!");
25456 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
25457 return nativeResponseValue;
25459 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
25461 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
25462 if(!isWasmInitialized) {
25463 throw new Error("initializeWasm() must be awaited first!");
25465 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
25466 // debug statements here
25468 // bool ChannelConfig_get_accept_underpaying_htlcs(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25470 export function ChannelConfig_get_accept_underpaying_htlcs(this_ptr: bigint): boolean {
25471 if(!isWasmInitialized) {
25472 throw new Error("initializeWasm() must be awaited first!");
25474 const nativeResponseValue = wasm.TS_ChannelConfig_get_accept_underpaying_htlcs(this_ptr);
25475 return nativeResponseValue;
25477 // void ChannelConfig_set_accept_underpaying_htlcs(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
25479 export function ChannelConfig_set_accept_underpaying_htlcs(this_ptr: bigint, val: boolean): void {
25480 if(!isWasmInitialized) {
25481 throw new Error("initializeWasm() must be awaited first!");
25483 const nativeResponseValue = wasm.TS_ChannelConfig_set_accept_underpaying_htlcs(this_ptr, val);
25484 // debug statements here
25486 // 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);
25488 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 {
25489 if(!isWasmInitialized) {
25490 throw new Error("initializeWasm() must be awaited first!");
25492 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);
25493 return nativeResponseValue;
25495 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
25497 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
25498 if(!isWasmInitialized) {
25499 throw new Error("initializeWasm() must be awaited first!");
25501 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
25502 return nativeResponseValue;
25504 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
25506 export function ChannelConfig_clone(orig: bigint): bigint {
25507 if(!isWasmInitialized) {
25508 throw new Error("initializeWasm() must be awaited first!");
25510 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
25511 return nativeResponseValue;
25513 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
25515 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
25516 if(!isWasmInitialized) {
25517 throw new Error("initializeWasm() must be awaited first!");
25519 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
25520 return nativeResponseValue;
25522 // void ChannelConfig_apply(struct LDKChannelConfig *NONNULL_PTR this_arg, const struct LDKChannelConfigUpdate *NONNULL_PTR update);
25524 export function ChannelConfig_apply(this_arg: bigint, update: bigint): void {
25525 if(!isWasmInitialized) {
25526 throw new Error("initializeWasm() must be awaited first!");
25528 const nativeResponseValue = wasm.TS_ChannelConfig_apply(this_arg, update);
25529 // debug statements here
25531 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
25533 export function ChannelConfig_default(): bigint {
25534 if(!isWasmInitialized) {
25535 throw new Error("initializeWasm() must be awaited first!");
25537 const nativeResponseValue = wasm.TS_ChannelConfig_default();
25538 return nativeResponseValue;
25540 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
25542 export function ChannelConfig_write(obj: bigint): number {
25543 if(!isWasmInitialized) {
25544 throw new Error("initializeWasm() must be awaited first!");
25546 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
25547 return nativeResponseValue;
25549 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
25551 export function ChannelConfig_read(ser: number): bigint {
25552 if(!isWasmInitialized) {
25553 throw new Error("initializeWasm() must be awaited first!");
25555 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
25556 return nativeResponseValue;
25558 // void ChannelConfigUpdate_free(struct LDKChannelConfigUpdate this_obj);
25560 export function ChannelConfigUpdate_free(this_obj: bigint): void {
25561 if(!isWasmInitialized) {
25562 throw new Error("initializeWasm() must be awaited first!");
25564 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_free(this_obj);
25565 // debug statements here
25567 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
25569 export function ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr: bigint): bigint {
25570 if(!isWasmInitialized) {
25571 throw new Error("initializeWasm() must be awaited first!");
25573 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr);
25574 return nativeResponseValue;
25576 // void ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
25578 export function ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: bigint): void {
25579 if(!isWasmInitialized) {
25580 throw new Error("initializeWasm() must be awaited first!");
25582 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr, val);
25583 // debug statements here
25585 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_base_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
25587 export function ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr: bigint): bigint {
25588 if(!isWasmInitialized) {
25589 throw new Error("initializeWasm() must be awaited first!");
25591 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr);
25592 return nativeResponseValue;
25594 // void ChannelConfigUpdate_set_forwarding_fee_base_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
25596 export function ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr: bigint, val: bigint): void {
25597 if(!isWasmInitialized) {
25598 throw new Error("initializeWasm() must be awaited first!");
25600 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr, val);
25601 // debug statements here
25603 // struct LDKCOption_u16Z ChannelConfigUpdate_get_cltv_expiry_delta(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
25605 export function ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr: bigint): bigint {
25606 if(!isWasmInitialized) {
25607 throw new Error("initializeWasm() must be awaited first!");
25609 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr);
25610 return nativeResponseValue;
25612 // void ChannelConfigUpdate_set_cltv_expiry_delta(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
25614 export function ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: bigint): void {
25615 if(!isWasmInitialized) {
25616 throw new Error("initializeWasm() must be awaited first!");
25618 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr, val);
25619 // debug statements here
25621 // struct LDKCOption_MaxDustHTLCExposureZ ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
25623 export function ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
25624 if(!isWasmInitialized) {
25625 throw new Error("initializeWasm() must be awaited first!");
25627 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr);
25628 return nativeResponseValue;
25630 // void ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_MaxDustHTLCExposureZ val);
25632 export function ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
25633 if(!isWasmInitialized) {
25634 throw new Error("initializeWasm() must be awaited first!");
25636 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr, val);
25637 // debug statements here
25639 // struct LDKCOption_u64Z ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
25641 export function ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
25642 if(!isWasmInitialized) {
25643 throw new Error("initializeWasm() must be awaited first!");
25645 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr);
25646 return nativeResponseValue;
25648 // void ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25650 export function ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
25651 if(!isWasmInitialized) {
25652 throw new Error("initializeWasm() must be awaited first!");
25654 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
25655 // debug statements here
25657 // 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);
25659 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 {
25660 if(!isWasmInitialized) {
25661 throw new Error("initializeWasm() must be awaited first!");
25663 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);
25664 return nativeResponseValue;
25666 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_default(void);
25668 export function ChannelConfigUpdate_default(): bigint {
25669 if(!isWasmInitialized) {
25670 throw new Error("initializeWasm() must be awaited first!");
25672 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_default();
25673 return nativeResponseValue;
25675 // void UserConfig_free(struct LDKUserConfig this_obj);
25677 export function UserConfig_free(this_obj: bigint): void {
25678 if(!isWasmInitialized) {
25679 throw new Error("initializeWasm() must be awaited first!");
25681 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
25682 // debug statements here
25684 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25686 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
25687 if(!isWasmInitialized) {
25688 throw new Error("initializeWasm() must be awaited first!");
25690 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
25691 return nativeResponseValue;
25693 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
25695 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
25696 if(!isWasmInitialized) {
25697 throw new Error("initializeWasm() must be awaited first!");
25699 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
25700 // debug statements here
25702 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25704 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
25705 if(!isWasmInitialized) {
25706 throw new Error("initializeWasm() must be awaited first!");
25708 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
25709 return nativeResponseValue;
25711 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
25713 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
25714 if(!isWasmInitialized) {
25715 throw new Error("initializeWasm() must be awaited first!");
25717 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
25718 // debug statements here
25720 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25722 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
25723 if(!isWasmInitialized) {
25724 throw new Error("initializeWasm() must be awaited first!");
25726 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
25727 return nativeResponseValue;
25729 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
25731 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
25732 if(!isWasmInitialized) {
25733 throw new Error("initializeWasm() must be awaited first!");
25735 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
25736 // debug statements here
25738 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25740 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
25741 if(!isWasmInitialized) {
25742 throw new Error("initializeWasm() must be awaited first!");
25744 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
25745 return nativeResponseValue;
25747 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
25749 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
25750 if(!isWasmInitialized) {
25751 throw new Error("initializeWasm() must be awaited first!");
25753 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
25754 // debug statements here
25756 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25758 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
25759 if(!isWasmInitialized) {
25760 throw new Error("initializeWasm() must be awaited first!");
25762 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
25763 return nativeResponseValue;
25765 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
25767 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
25768 if(!isWasmInitialized) {
25769 throw new Error("initializeWasm() must be awaited first!");
25771 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
25772 // debug statements here
25774 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25776 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
25777 if(!isWasmInitialized) {
25778 throw new Error("initializeWasm() must be awaited first!");
25780 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
25781 return nativeResponseValue;
25783 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
25785 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
25786 if(!isWasmInitialized) {
25787 throw new Error("initializeWasm() must be awaited first!");
25789 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
25790 // debug statements here
25792 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25794 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
25795 if(!isWasmInitialized) {
25796 throw new Error("initializeWasm() must be awaited first!");
25798 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
25799 return nativeResponseValue;
25801 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
25803 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
25804 if(!isWasmInitialized) {
25805 throw new Error("initializeWasm() must be awaited first!");
25807 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
25808 // debug statements here
25810 // bool UserConfig_get_accept_mpp_keysend(const struct LDKUserConfig *NONNULL_PTR this_ptr);
25812 export function UserConfig_get_accept_mpp_keysend(this_ptr: bigint): boolean {
25813 if(!isWasmInitialized) {
25814 throw new Error("initializeWasm() must be awaited first!");
25816 const nativeResponseValue = wasm.TS_UserConfig_get_accept_mpp_keysend(this_ptr);
25817 return nativeResponseValue;
25819 // void UserConfig_set_accept_mpp_keysend(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
25821 export function UserConfig_set_accept_mpp_keysend(this_ptr: bigint, val: boolean): void {
25822 if(!isWasmInitialized) {
25823 throw new Error("initializeWasm() must be awaited first!");
25825 const nativeResponseValue = wasm.TS_UserConfig_set_accept_mpp_keysend(this_ptr, val);
25826 // debug statements here
25828 // 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);
25830 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 {
25831 if(!isWasmInitialized) {
25832 throw new Error("initializeWasm() must be awaited first!");
25834 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);
25835 return nativeResponseValue;
25837 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
25839 export function UserConfig_clone_ptr(arg: bigint): bigint {
25840 if(!isWasmInitialized) {
25841 throw new Error("initializeWasm() must be awaited first!");
25843 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
25844 return nativeResponseValue;
25846 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
25848 export function UserConfig_clone(orig: bigint): bigint {
25849 if(!isWasmInitialized) {
25850 throw new Error("initializeWasm() must be awaited first!");
25852 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
25853 return nativeResponseValue;
25855 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
25857 export function UserConfig_default(): bigint {
25858 if(!isWasmInitialized) {
25859 throw new Error("initializeWasm() must be awaited first!");
25861 const nativeResponseValue = wasm.TS_UserConfig_default();
25862 return nativeResponseValue;
25864 // void BestBlock_free(struct LDKBestBlock this_obj);
25866 export function BestBlock_free(this_obj: bigint): void {
25867 if(!isWasmInitialized) {
25868 throw new Error("initializeWasm() must be awaited first!");
25870 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
25871 // debug statements here
25873 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
25875 export function BestBlock_clone_ptr(arg: bigint): bigint {
25876 if(!isWasmInitialized) {
25877 throw new Error("initializeWasm() must be awaited first!");
25879 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
25880 return nativeResponseValue;
25882 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
25884 export function BestBlock_clone(orig: bigint): bigint {
25885 if(!isWasmInitialized) {
25886 throw new Error("initializeWasm() must be awaited first!");
25888 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
25889 return nativeResponseValue;
25891 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
25893 export function BestBlock_eq(a: bigint, b: bigint): boolean {
25894 if(!isWasmInitialized) {
25895 throw new Error("initializeWasm() must be awaited first!");
25897 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
25898 return nativeResponseValue;
25900 // MUST_USE_RES struct LDKBestBlock BestBlock_from_network(enum LDKNetwork network);
25902 export function BestBlock_from_network(network: Network): bigint {
25903 if(!isWasmInitialized) {
25904 throw new Error("initializeWasm() must be awaited first!");
25906 const nativeResponseValue = wasm.TS_BestBlock_from_network(network);
25907 return nativeResponseValue;
25909 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
25911 export function BestBlock_new(block_hash: number, height: number): bigint {
25912 if(!isWasmInitialized) {
25913 throw new Error("initializeWasm() must be awaited first!");
25915 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
25916 return nativeResponseValue;
25918 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
25920 export function BestBlock_block_hash(this_arg: bigint): number {
25921 if(!isWasmInitialized) {
25922 throw new Error("initializeWasm() must be awaited first!");
25924 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
25925 return nativeResponseValue;
25927 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
25929 export function BestBlock_height(this_arg: bigint): number {
25930 if(!isWasmInitialized) {
25931 throw new Error("initializeWasm() must be awaited first!");
25933 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
25934 return nativeResponseValue;
25936 // void Listen_free(struct LDKListen this_ptr);
25938 export function Listen_free(this_ptr: bigint): void {
25939 if(!isWasmInitialized) {
25940 throw new Error("initializeWasm() must be awaited first!");
25942 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
25943 // debug statements here
25945 // void Confirm_free(struct LDKConfirm this_ptr);
25947 export function Confirm_free(this_ptr: bigint): void {
25948 if(!isWasmInitialized) {
25949 throw new Error("initializeWasm() must be awaited first!");
25951 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
25952 // debug statements here
25954 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
25956 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
25957 if(!isWasmInitialized) {
25958 throw new Error("initializeWasm() must be awaited first!");
25960 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
25961 return nativeResponseValue;
25963 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
25965 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
25966 if(!isWasmInitialized) {
25967 throw new Error("initializeWasm() must be awaited first!");
25969 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
25970 return nativeResponseValue;
25972 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
25974 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
25975 if(!isWasmInitialized) {
25976 throw new Error("initializeWasm() must be awaited first!");
25978 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
25979 return nativeResponseValue;
25981 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_unrecoverable_error(void);
25983 export function ChannelMonitorUpdateStatus_unrecoverable_error(): ChannelMonitorUpdateStatus {
25984 if(!isWasmInitialized) {
25985 throw new Error("initializeWasm() must be awaited first!");
25987 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_unrecoverable_error();
25988 return nativeResponseValue;
25990 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
25992 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
25993 if(!isWasmInitialized) {
25994 throw new Error("initializeWasm() must be awaited first!");
25996 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
25997 return nativeResponseValue;
25999 // void Watch_free(struct LDKWatch this_ptr);
26001 export function Watch_free(this_ptr: bigint): void {
26002 if(!isWasmInitialized) {
26003 throw new Error("initializeWasm() must be awaited first!");
26005 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
26006 // debug statements here
26008 // void Filter_free(struct LDKFilter this_ptr);
26010 export function Filter_free(this_ptr: bigint): void {
26011 if(!isWasmInitialized) {
26012 throw new Error("initializeWasm() must be awaited first!");
26014 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
26015 // debug statements here
26017 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
26019 export function WatchedOutput_free(this_obj: bigint): void {
26020 if(!isWasmInitialized) {
26021 throw new Error("initializeWasm() must be awaited first!");
26023 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
26024 // debug statements here
26026 // struct LDKCOption_ThirtyTwoBytesZ WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
26028 export function WatchedOutput_get_block_hash(this_ptr: bigint): bigint {
26029 if(!isWasmInitialized) {
26030 throw new Error("initializeWasm() must be awaited first!");
26032 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
26033 return nativeResponseValue;
26035 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
26037 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: bigint): void {
26038 if(!isWasmInitialized) {
26039 throw new Error("initializeWasm() must be awaited first!");
26041 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
26042 // debug statements here
26044 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
26046 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
26047 if(!isWasmInitialized) {
26048 throw new Error("initializeWasm() must be awaited first!");
26050 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
26051 return nativeResponseValue;
26053 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
26055 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
26056 if(!isWasmInitialized) {
26057 throw new Error("initializeWasm() must be awaited first!");
26059 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
26060 // debug statements here
26062 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
26064 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
26065 if(!isWasmInitialized) {
26066 throw new Error("initializeWasm() must be awaited first!");
26068 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
26069 return nativeResponseValue;
26071 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
26073 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
26074 if(!isWasmInitialized) {
26075 throw new Error("initializeWasm() must be awaited first!");
26077 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
26078 // debug statements here
26080 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKCOption_ThirtyTwoBytesZ block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
26082 export function WatchedOutput_new(block_hash_arg: bigint, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
26083 if(!isWasmInitialized) {
26084 throw new Error("initializeWasm() must be awaited first!");
26086 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
26087 return nativeResponseValue;
26089 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
26091 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
26092 if(!isWasmInitialized) {
26093 throw new Error("initializeWasm() must be awaited first!");
26095 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
26096 return nativeResponseValue;
26098 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
26100 export function WatchedOutput_clone(orig: bigint): bigint {
26101 if(!isWasmInitialized) {
26102 throw new Error("initializeWasm() must be awaited first!");
26104 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
26105 return nativeResponseValue;
26107 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
26109 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
26110 if(!isWasmInitialized) {
26111 throw new Error("initializeWasm() must be awaited first!");
26113 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
26114 return nativeResponseValue;
26116 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
26118 export function WatchedOutput_hash(o: bigint): bigint {
26119 if(!isWasmInitialized) {
26120 throw new Error("initializeWasm() must be awaited first!");
26122 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
26123 return nativeResponseValue;
26125 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
26127 export function BroadcasterInterface_free(this_ptr: bigint): void {
26128 if(!isWasmInitialized) {
26129 throw new Error("initializeWasm() must be awaited first!");
26131 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
26132 // debug statements here
26134 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
26136 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
26137 if(!isWasmInitialized) {
26138 throw new Error("initializeWasm() must be awaited first!");
26140 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
26141 return nativeResponseValue;
26143 // enum LDKConfirmationTarget ConfirmationTarget_mempool_minimum(void);
26145 export function ConfirmationTarget_mempool_minimum(): ConfirmationTarget {
26146 if(!isWasmInitialized) {
26147 throw new Error("initializeWasm() must be awaited first!");
26149 const nativeResponseValue = wasm.TS_ConfirmationTarget_mempool_minimum();
26150 return nativeResponseValue;
26152 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
26154 export function ConfirmationTarget_background(): ConfirmationTarget {
26155 if(!isWasmInitialized) {
26156 throw new Error("initializeWasm() must be awaited first!");
26158 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
26159 return nativeResponseValue;
26161 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
26163 export function ConfirmationTarget_normal(): ConfirmationTarget {
26164 if(!isWasmInitialized) {
26165 throw new Error("initializeWasm() must be awaited first!");
26167 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
26168 return nativeResponseValue;
26170 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
26172 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
26173 if(!isWasmInitialized) {
26174 throw new Error("initializeWasm() must be awaited first!");
26176 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
26177 return nativeResponseValue;
26179 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
26181 export function ConfirmationTarget_hash(o: bigint): bigint {
26182 if(!isWasmInitialized) {
26183 throw new Error("initializeWasm() must be awaited first!");
26185 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
26186 return nativeResponseValue;
26188 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
26190 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
26191 if(!isWasmInitialized) {
26192 throw new Error("initializeWasm() must be awaited first!");
26194 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
26195 return nativeResponseValue;
26197 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
26199 export function FeeEstimator_free(this_ptr: bigint): void {
26200 if(!isWasmInitialized) {
26201 throw new Error("initializeWasm() must be awaited first!");
26203 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
26204 // debug statements here
26206 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
26208 export function MonitorUpdateId_free(this_obj: bigint): void {
26209 if(!isWasmInitialized) {
26210 throw new Error("initializeWasm() must be awaited first!");
26212 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
26213 // debug statements here
26215 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
26217 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
26218 if(!isWasmInitialized) {
26219 throw new Error("initializeWasm() must be awaited first!");
26221 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
26222 return nativeResponseValue;
26224 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
26226 export function MonitorUpdateId_clone(orig: bigint): bigint {
26227 if(!isWasmInitialized) {
26228 throw new Error("initializeWasm() must be awaited first!");
26230 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
26231 return nativeResponseValue;
26233 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
26235 export function MonitorUpdateId_hash(o: bigint): bigint {
26236 if(!isWasmInitialized) {
26237 throw new Error("initializeWasm() must be awaited first!");
26239 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
26240 return nativeResponseValue;
26242 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
26244 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
26245 if(!isWasmInitialized) {
26246 throw new Error("initializeWasm() must be awaited first!");
26248 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
26249 return nativeResponseValue;
26251 // void Persist_free(struct LDKPersist this_ptr);
26253 export function Persist_free(this_ptr: bigint): void {
26254 if(!isWasmInitialized) {
26255 throw new Error("initializeWasm() must be awaited first!");
26257 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
26258 // debug statements here
26260 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
26262 export function LockedChannelMonitor_free(this_obj: bigint): void {
26263 if(!isWasmInitialized) {
26264 throw new Error("initializeWasm() must be awaited first!");
26266 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
26267 // debug statements here
26269 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
26271 export function ChainMonitor_free(this_obj: bigint): void {
26272 if(!isWasmInitialized) {
26273 throw new Error("initializeWasm() must be awaited first!");
26275 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
26276 // debug statements here
26278 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
26280 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
26281 if(!isWasmInitialized) {
26282 throw new Error("initializeWasm() must be awaited first!");
26284 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
26285 return nativeResponseValue;
26287 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
26289 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
26290 if(!isWasmInitialized) {
26291 throw new Error("initializeWasm() must be awaited first!");
26293 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
26294 return nativeResponseValue;
26296 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
26298 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
26299 if(!isWasmInitialized) {
26300 throw new Error("initializeWasm() must be awaited first!");
26302 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
26303 return nativeResponseValue;
26305 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26307 export function ChainMonitor_list_monitors(this_arg: bigint): number {
26308 if(!isWasmInitialized) {
26309 throw new Error("initializeWasm() must be awaited first!");
26311 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
26312 return nativeResponseValue;
26314 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26316 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
26317 if(!isWasmInitialized) {
26318 throw new Error("initializeWasm() must be awaited first!");
26320 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
26321 return nativeResponseValue;
26323 // 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);
26325 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
26326 if(!isWasmInitialized) {
26327 throw new Error("initializeWasm() must be awaited first!");
26329 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
26330 return nativeResponseValue;
26332 // MUST_USE_RES struct LDKFuture ChainMonitor_get_update_future(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26334 export function ChainMonitor_get_update_future(this_arg: bigint): bigint {
26335 if(!isWasmInitialized) {
26336 throw new Error("initializeWasm() must be awaited first!");
26338 const nativeResponseValue = wasm.TS_ChainMonitor_get_update_future(this_arg);
26339 return nativeResponseValue;
26341 // void ChainMonitor_rebroadcast_pending_claims(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26343 export function ChainMonitor_rebroadcast_pending_claims(this_arg: bigint): void {
26344 if(!isWasmInitialized) {
26345 throw new Error("initializeWasm() must be awaited first!");
26347 const nativeResponseValue = wasm.TS_ChainMonitor_rebroadcast_pending_claims(this_arg);
26348 // debug statements here
26350 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26352 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
26353 if(!isWasmInitialized) {
26354 throw new Error("initializeWasm() must be awaited first!");
26356 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
26357 return nativeResponseValue;
26359 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26361 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
26362 if(!isWasmInitialized) {
26363 throw new Error("initializeWasm() must be awaited first!");
26365 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
26366 return nativeResponseValue;
26368 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26370 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
26371 if(!isWasmInitialized) {
26372 throw new Error("initializeWasm() must be awaited first!");
26374 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
26375 return nativeResponseValue;
26377 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26379 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
26380 if(!isWasmInitialized) {
26381 throw new Error("initializeWasm() must be awaited first!");
26383 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
26384 return nativeResponseValue;
26386 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
26388 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
26389 if(!isWasmInitialized) {
26390 throw new Error("initializeWasm() must be awaited first!");
26392 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
26393 // debug statements here
26395 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
26397 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
26398 if(!isWasmInitialized) {
26399 throw new Error("initializeWasm() must be awaited first!");
26401 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
26402 return nativeResponseValue;
26404 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
26406 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
26407 if(!isWasmInitialized) {
26408 throw new Error("initializeWasm() must be awaited first!");
26410 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
26411 // debug statements here
26413 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
26415 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
26416 if(!isWasmInitialized) {
26417 throw new Error("initializeWasm() must be awaited first!");
26419 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
26420 return nativeResponseValue;
26422 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
26424 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
26425 if(!isWasmInitialized) {
26426 throw new Error("initializeWasm() must be awaited first!");
26428 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
26429 return nativeResponseValue;
26431 // bool ChannelMonitorUpdate_eq(const struct LDKChannelMonitorUpdate *NONNULL_PTR a, const struct LDKChannelMonitorUpdate *NONNULL_PTR b);
26433 export function ChannelMonitorUpdate_eq(a: bigint, b: bigint): boolean {
26434 if(!isWasmInitialized) {
26435 throw new Error("initializeWasm() must be awaited first!");
26437 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_eq(a, b);
26438 return nativeResponseValue;
26440 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
26442 export function ChannelMonitorUpdate_write(obj: bigint): number {
26443 if(!isWasmInitialized) {
26444 throw new Error("initializeWasm() must be awaited first!");
26446 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
26447 return nativeResponseValue;
26449 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
26451 export function ChannelMonitorUpdate_read(ser: number): bigint {
26452 if(!isWasmInitialized) {
26453 throw new Error("initializeWasm() must be awaited first!");
26455 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
26456 return nativeResponseValue;
26458 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
26460 export function MonitorEvent_free(this_ptr: bigint): void {
26461 if(!isWasmInitialized) {
26462 throw new Error("initializeWasm() must be awaited first!");
26464 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
26465 // debug statements here
26467 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
26469 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
26470 if(!isWasmInitialized) {
26471 throw new Error("initializeWasm() must be awaited first!");
26473 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
26474 return nativeResponseValue;
26476 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
26478 export function MonitorEvent_clone(orig: bigint): bigint {
26479 if(!isWasmInitialized) {
26480 throw new Error("initializeWasm() must be awaited first!");
26482 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
26483 return nativeResponseValue;
26485 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
26487 export function MonitorEvent_htlcevent(a: bigint): bigint {
26488 if(!isWasmInitialized) {
26489 throw new Error("initializeWasm() must be awaited first!");
26491 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
26492 return nativeResponseValue;
26494 // struct LDKMonitorEvent MonitorEvent_holder_force_closed(struct LDKOutPoint a);
26496 export function MonitorEvent_holder_force_closed(a: bigint): bigint {
26497 if(!isWasmInitialized) {
26498 throw new Error("initializeWasm() must be awaited first!");
26500 const nativeResponseValue = wasm.TS_MonitorEvent_holder_force_closed(a);
26501 return nativeResponseValue;
26503 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
26505 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
26506 if(!isWasmInitialized) {
26507 throw new Error("initializeWasm() must be awaited first!");
26509 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
26510 return nativeResponseValue;
26512 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
26514 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
26515 if(!isWasmInitialized) {
26516 throw new Error("initializeWasm() must be awaited first!");
26518 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
26519 return nativeResponseValue;
26521 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
26523 export function MonitorEvent_write(obj: bigint): number {
26524 if(!isWasmInitialized) {
26525 throw new Error("initializeWasm() must be awaited first!");
26527 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
26528 return nativeResponseValue;
26530 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
26532 export function MonitorEvent_read(ser: number): bigint {
26533 if(!isWasmInitialized) {
26534 throw new Error("initializeWasm() must be awaited first!");
26536 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
26537 return nativeResponseValue;
26539 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
26541 export function HTLCUpdate_free(this_obj: bigint): void {
26542 if(!isWasmInitialized) {
26543 throw new Error("initializeWasm() must be awaited first!");
26545 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
26546 // debug statements here
26548 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
26550 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
26551 if(!isWasmInitialized) {
26552 throw new Error("initializeWasm() must be awaited first!");
26554 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
26555 return nativeResponseValue;
26557 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
26559 export function HTLCUpdate_clone(orig: bigint): bigint {
26560 if(!isWasmInitialized) {
26561 throw new Error("initializeWasm() must be awaited first!");
26563 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
26564 return nativeResponseValue;
26566 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
26568 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
26569 if(!isWasmInitialized) {
26570 throw new Error("initializeWasm() must be awaited first!");
26572 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
26573 return nativeResponseValue;
26575 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
26577 export function HTLCUpdate_write(obj: bigint): number {
26578 if(!isWasmInitialized) {
26579 throw new Error("initializeWasm() must be awaited first!");
26581 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
26582 return nativeResponseValue;
26584 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
26586 export function HTLCUpdate_read(ser: number): bigint {
26587 if(!isWasmInitialized) {
26588 throw new Error("initializeWasm() must be awaited first!");
26590 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
26591 return nativeResponseValue;
26593 // void Balance_free(struct LDKBalance this_ptr);
26595 export function Balance_free(this_ptr: bigint): void {
26596 if(!isWasmInitialized) {
26597 throw new Error("initializeWasm() must be awaited first!");
26599 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
26600 // debug statements here
26602 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
26604 export function Balance_clone_ptr(arg: bigint): bigint {
26605 if(!isWasmInitialized) {
26606 throw new Error("initializeWasm() must be awaited first!");
26608 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
26609 return nativeResponseValue;
26611 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
26613 export function Balance_clone(orig: bigint): bigint {
26614 if(!isWasmInitialized) {
26615 throw new Error("initializeWasm() must be awaited first!");
26617 const nativeResponseValue = wasm.TS_Balance_clone(orig);
26618 return nativeResponseValue;
26620 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t amount_satoshis);
26622 export function Balance_claimable_on_channel_close(amount_satoshis: bigint): bigint {
26623 if(!isWasmInitialized) {
26624 throw new Error("initializeWasm() must be awaited first!");
26626 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(amount_satoshis);
26627 return nativeResponseValue;
26629 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t amount_satoshis, uint32_t confirmation_height);
26631 export function Balance_claimable_awaiting_confirmations(amount_satoshis: bigint, confirmation_height: number): bigint {
26632 if(!isWasmInitialized) {
26633 throw new Error("initializeWasm() must be awaited first!");
26635 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(amount_satoshis, confirmation_height);
26636 return nativeResponseValue;
26638 // struct LDKBalance Balance_contentious_claimable(uint64_t amount_satoshis, uint32_t timeout_height, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_preimage);
26640 export function Balance_contentious_claimable(amount_satoshis: bigint, timeout_height: number, payment_hash: number, payment_preimage: number): bigint {
26641 if(!isWasmInitialized) {
26642 throw new Error("initializeWasm() must be awaited first!");
26644 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(amount_satoshis, timeout_height, payment_hash, payment_preimage);
26645 return nativeResponseValue;
26647 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t amount_satoshis, uint32_t claimable_height, struct LDKThirtyTwoBytes payment_hash);
26649 export function Balance_maybe_timeout_claimable_htlc(amount_satoshis: bigint, claimable_height: number, payment_hash: number): bigint {
26650 if(!isWasmInitialized) {
26651 throw new Error("initializeWasm() must be awaited first!");
26653 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(amount_satoshis, claimable_height, payment_hash);
26654 return nativeResponseValue;
26656 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t amount_satoshis, uint32_t expiry_height, struct LDKThirtyTwoBytes payment_hash);
26658 export function Balance_maybe_preimage_claimable_htlc(amount_satoshis: bigint, expiry_height: number, payment_hash: number): bigint {
26659 if(!isWasmInitialized) {
26660 throw new Error("initializeWasm() must be awaited first!");
26662 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(amount_satoshis, expiry_height, payment_hash);
26663 return nativeResponseValue;
26665 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t amount_satoshis);
26667 export function Balance_counterparty_revoked_output_claimable(amount_satoshis: bigint): bigint {
26668 if(!isWasmInitialized) {
26669 throw new Error("initializeWasm() must be awaited first!");
26671 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(amount_satoshis);
26672 return nativeResponseValue;
26674 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
26676 export function Balance_eq(a: bigint, b: bigint): boolean {
26677 if(!isWasmInitialized) {
26678 throw new Error("initializeWasm() must be awaited first!");
26680 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
26681 return nativeResponseValue;
26683 // MUST_USE_RES uint64_t Balance_claimable_amount_satoshis(const struct LDKBalance *NONNULL_PTR this_arg);
26685 export function Balance_claimable_amount_satoshis(this_arg: bigint): bigint {
26686 if(!isWasmInitialized) {
26687 throw new Error("initializeWasm() must be awaited first!");
26689 const nativeResponseValue = wasm.TS_Balance_claimable_amount_satoshis(this_arg);
26690 return nativeResponseValue;
26692 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
26694 export function ChannelMonitor_free(this_obj: bigint): void {
26695 if(!isWasmInitialized) {
26696 throw new Error("initializeWasm() must be awaited first!");
26698 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
26699 // debug statements here
26701 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
26703 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
26704 if(!isWasmInitialized) {
26705 throw new Error("initializeWasm() must be awaited first!");
26707 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
26708 return nativeResponseValue;
26710 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
26712 export function ChannelMonitor_clone(orig: bigint): bigint {
26713 if(!isWasmInitialized) {
26714 throw new Error("initializeWasm() must be awaited first!");
26716 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
26717 return nativeResponseValue;
26719 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
26721 export function ChannelMonitor_write(obj: bigint): number {
26722 if(!isWasmInitialized) {
26723 throw new Error("initializeWasm() must be awaited first!");
26725 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
26726 return nativeResponseValue;
26728 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
26730 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
26731 if(!isWasmInitialized) {
26732 throw new Error("initializeWasm() must be awaited first!");
26734 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
26735 return nativeResponseValue;
26737 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26739 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
26740 if(!isWasmInitialized) {
26741 throw new Error("initializeWasm() must be awaited first!");
26743 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
26744 return nativeResponseValue;
26746 // MUST_USE_RES struct LDKC2Tuple_OutPointCVec_u8ZZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26748 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
26749 if(!isWasmInitialized) {
26750 throw new Error("initializeWasm() must be awaited first!");
26752 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
26753 return nativeResponseValue;
26755 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26757 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
26758 if(!isWasmInitialized) {
26759 throw new Error("initializeWasm() must be awaited first!");
26761 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
26762 return nativeResponseValue;
26764 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
26766 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
26767 if(!isWasmInitialized) {
26768 throw new Error("initializeWasm() must be awaited first!");
26770 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
26771 // debug statements here
26773 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26775 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
26776 if(!isWasmInitialized) {
26777 throw new Error("initializeWasm() must be awaited first!");
26779 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
26780 return nativeResponseValue;
26782 // void ChannelMonitor_process_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKEventHandler *NONNULL_PTR handler);
26784 export function ChannelMonitor_process_pending_events(this_arg: bigint, handler: bigint): void {
26785 if(!isWasmInitialized) {
26786 throw new Error("initializeWasm() must be awaited first!");
26788 const nativeResponseValue = wasm.TS_ChannelMonitor_process_pending_events(this_arg, handler);
26789 // debug statements here
26791 // MUST_USE_RES struct LDKCommitmentTransaction ChannelMonitor_initial_counterparty_commitment_tx(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26793 export function ChannelMonitor_initial_counterparty_commitment_tx(this_arg: bigint): bigint {
26794 if(!isWasmInitialized) {
26795 throw new Error("initializeWasm() must be awaited first!");
26797 const nativeResponseValue = wasm.TS_ChannelMonitor_initial_counterparty_commitment_tx(this_arg);
26798 return nativeResponseValue;
26800 // MUST_USE_RES struct LDKCVec_CommitmentTransactionZ ChannelMonitor_counterparty_commitment_txs_from_update(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
26802 export function ChannelMonitor_counterparty_commitment_txs_from_update(this_arg: bigint, update: bigint): number {
26803 if(!isWasmInitialized) {
26804 throw new Error("initializeWasm() must be awaited first!");
26806 const nativeResponseValue = wasm.TS_ChannelMonitor_counterparty_commitment_txs_from_update(this_arg, update);
26807 return nativeResponseValue;
26809 // MUST_USE_RES struct LDKCResult_TransactionNoneZ ChannelMonitor_sign_to_local_justice_tx(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input_idx, uint64_t value, uint64_t commitment_number);
26811 export function ChannelMonitor_sign_to_local_justice_tx(this_arg: bigint, justice_tx: number, input_idx: number, value: bigint, commitment_number: bigint): bigint {
26812 if(!isWasmInitialized) {
26813 throw new Error("initializeWasm() must be awaited first!");
26815 const nativeResponseValue = wasm.TS_ChannelMonitor_sign_to_local_justice_tx(this_arg, justice_tx, input_idx, value, commitment_number);
26816 return nativeResponseValue;
26818 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26820 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
26821 if(!isWasmInitialized) {
26822 throw new Error("initializeWasm() must be awaited first!");
26824 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
26825 return nativeResponseValue;
26827 // 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);
26829 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
26830 if(!isWasmInitialized) {
26831 throw new Error("initializeWasm() must be awaited first!");
26833 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
26834 return nativeResponseValue;
26836 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_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);
26838 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
26839 if(!isWasmInitialized) {
26840 throw new Error("initializeWasm() must be awaited first!");
26842 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
26843 return nativeResponseValue;
26845 // 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);
26847 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
26848 if(!isWasmInitialized) {
26849 throw new Error("initializeWasm() must be awaited first!");
26851 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
26852 // debug statements here
26854 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_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);
26856 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
26857 if(!isWasmInitialized) {
26858 throw new Error("initializeWasm() must be awaited first!");
26860 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
26861 return nativeResponseValue;
26863 // 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);
26865 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
26866 if(!isWasmInitialized) {
26867 throw new Error("initializeWasm() must be awaited first!");
26869 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
26870 // debug statements here
26872 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_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);
26874 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
26875 if(!isWasmInitialized) {
26876 throw new Error("initializeWasm() must be awaited first!");
26878 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
26879 return nativeResponseValue;
26881 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26883 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
26884 if(!isWasmInitialized) {
26885 throw new Error("initializeWasm() must be awaited first!");
26887 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
26888 return nativeResponseValue;
26890 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26892 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
26893 if(!isWasmInitialized) {
26894 throw new Error("initializeWasm() must be awaited first!");
26896 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
26897 return nativeResponseValue;
26899 // void ChannelMonitor_rebroadcast_pending_claims(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
26901 export function ChannelMonitor_rebroadcast_pending_claims(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
26902 if(!isWasmInitialized) {
26903 throw new Error("initializeWasm() must be awaited first!");
26905 const nativeResponseValue = wasm.TS_ChannelMonitor_rebroadcast_pending_claims(this_arg, broadcaster, fee_estimator, logger);
26906 // debug statements here
26908 // MUST_USE_RES struct LDKCVec_SpendableOutputDescriptorZ ChannelMonitor_get_spendable_outputs(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKTransaction tx, uint32_t confirmation_height);
26910 export function ChannelMonitor_get_spendable_outputs(this_arg: bigint, tx: number, confirmation_height: number): number {
26911 if(!isWasmInitialized) {
26912 throw new Error("initializeWasm() must be awaited first!");
26914 const nativeResponseValue = wasm.TS_ChannelMonitor_get_spendable_outputs(this_arg, tx, confirmation_height);
26915 return nativeResponseValue;
26917 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
26919 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
26920 if(!isWasmInitialized) {
26921 throw new Error("initializeWasm() must be awaited first!");
26923 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
26924 return nativeResponseValue;
26926 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKEntropySource *NONNULL_PTR arg_a, const struct LDKSignerProvider *NONNULL_PTR arg_b);
26928 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
26929 if(!isWasmInitialized) {
26930 throw new Error("initializeWasm() must be awaited first!");
26932 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser, arg_a, arg_b);
26933 return nativeResponseValue;
26935 // void OutPoint_free(struct LDKOutPoint this_obj);
26937 export function OutPoint_free(this_obj: bigint): void {
26938 if(!isWasmInitialized) {
26939 throw new Error("initializeWasm() must be awaited first!");
26941 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
26942 // debug statements here
26944 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
26946 export function OutPoint_get_txid(this_ptr: bigint): number {
26947 if(!isWasmInitialized) {
26948 throw new Error("initializeWasm() must be awaited first!");
26950 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
26951 return nativeResponseValue;
26953 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26955 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
26956 if(!isWasmInitialized) {
26957 throw new Error("initializeWasm() must be awaited first!");
26959 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
26960 // debug statements here
26962 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
26964 export function OutPoint_get_index(this_ptr: bigint): number {
26965 if(!isWasmInitialized) {
26966 throw new Error("initializeWasm() must be awaited first!");
26968 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
26969 return nativeResponseValue;
26971 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
26973 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
26974 if(!isWasmInitialized) {
26975 throw new Error("initializeWasm() must be awaited first!");
26977 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
26978 // debug statements here
26980 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
26982 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
26983 if(!isWasmInitialized) {
26984 throw new Error("initializeWasm() must be awaited first!");
26986 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
26987 return nativeResponseValue;
26989 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
26991 export function OutPoint_clone_ptr(arg: bigint): bigint {
26992 if(!isWasmInitialized) {
26993 throw new Error("initializeWasm() must be awaited first!");
26995 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
26996 return nativeResponseValue;
26998 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
27000 export function OutPoint_clone(orig: bigint): bigint {
27001 if(!isWasmInitialized) {
27002 throw new Error("initializeWasm() must be awaited first!");
27004 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
27005 return nativeResponseValue;
27007 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
27009 export function OutPoint_eq(a: bigint, b: bigint): boolean {
27010 if(!isWasmInitialized) {
27011 throw new Error("initializeWasm() must be awaited first!");
27013 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
27014 return nativeResponseValue;
27016 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
27018 export function OutPoint_hash(o: bigint): bigint {
27019 if(!isWasmInitialized) {
27020 throw new Error("initializeWasm() must be awaited first!");
27022 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
27023 return nativeResponseValue;
27025 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
27027 export function OutPoint_to_channel_id(this_arg: bigint): number {
27028 if(!isWasmInitialized) {
27029 throw new Error("initializeWasm() must be awaited first!");
27031 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
27032 return nativeResponseValue;
27034 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
27036 export function OutPoint_write(obj: bigint): number {
27037 if(!isWasmInitialized) {
27038 throw new Error("initializeWasm() must be awaited first!");
27040 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
27041 return nativeResponseValue;
27043 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
27045 export function OutPoint_read(ser: number): bigint {
27046 if(!isWasmInitialized) {
27047 throw new Error("initializeWasm() must be awaited first!");
27049 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
27050 return nativeResponseValue;
27052 // void FailureCode_free(struct LDKFailureCode this_ptr);
27054 export function FailureCode_free(this_ptr: bigint): void {
27055 if(!isWasmInitialized) {
27056 throw new Error("initializeWasm() must be awaited first!");
27058 const nativeResponseValue = wasm.TS_FailureCode_free(this_ptr);
27059 // debug statements here
27061 // uint64_t FailureCode_clone_ptr(LDKFailureCode *NONNULL_PTR arg);
27063 export function FailureCode_clone_ptr(arg: bigint): bigint {
27064 if(!isWasmInitialized) {
27065 throw new Error("initializeWasm() must be awaited first!");
27067 const nativeResponseValue = wasm.TS_FailureCode_clone_ptr(arg);
27068 return nativeResponseValue;
27070 // struct LDKFailureCode FailureCode_clone(const struct LDKFailureCode *NONNULL_PTR orig);
27072 export function FailureCode_clone(orig: bigint): bigint {
27073 if(!isWasmInitialized) {
27074 throw new Error("initializeWasm() must be awaited first!");
27076 const nativeResponseValue = wasm.TS_FailureCode_clone(orig);
27077 return nativeResponseValue;
27079 // struct LDKFailureCode FailureCode_temporary_node_failure(void);
27081 export function FailureCode_temporary_node_failure(): bigint {
27082 if(!isWasmInitialized) {
27083 throw new Error("initializeWasm() must be awaited first!");
27085 const nativeResponseValue = wasm.TS_FailureCode_temporary_node_failure();
27086 return nativeResponseValue;
27088 // struct LDKFailureCode FailureCode_required_node_feature_missing(void);
27090 export function FailureCode_required_node_feature_missing(): bigint {
27091 if(!isWasmInitialized) {
27092 throw new Error("initializeWasm() must be awaited first!");
27094 const nativeResponseValue = wasm.TS_FailureCode_required_node_feature_missing();
27095 return nativeResponseValue;
27097 // struct LDKFailureCode FailureCode_incorrect_or_unknown_payment_details(void);
27099 export function FailureCode_incorrect_or_unknown_payment_details(): bigint {
27100 if(!isWasmInitialized) {
27101 throw new Error("initializeWasm() must be awaited first!");
27103 const nativeResponseValue = wasm.TS_FailureCode_incorrect_or_unknown_payment_details();
27104 return nativeResponseValue;
27106 // struct LDKFailureCode FailureCode_invalid_onion_payload(struct LDKCOption_C2Tuple_u64u16ZZ a);
27108 export function FailureCode_invalid_onion_payload(a: bigint): bigint {
27109 if(!isWasmInitialized) {
27110 throw new Error("initializeWasm() must be awaited first!");
27112 const nativeResponseValue = wasm.TS_FailureCode_invalid_onion_payload(a);
27113 return nativeResponseValue;
27115 // void ChannelManager_free(struct LDKChannelManager this_obj);
27117 export function ChannelManager_free(this_obj: bigint): void {
27118 if(!isWasmInitialized) {
27119 throw new Error("initializeWasm() must be awaited first!");
27121 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
27122 // debug statements here
27124 // void ChainParameters_free(struct LDKChainParameters this_obj);
27126 export function ChainParameters_free(this_obj: bigint): void {
27127 if(!isWasmInitialized) {
27128 throw new Error("initializeWasm() must be awaited first!");
27130 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
27131 // debug statements here
27133 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
27135 export function ChainParameters_get_network(this_ptr: bigint): Network {
27136 if(!isWasmInitialized) {
27137 throw new Error("initializeWasm() must be awaited first!");
27139 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
27140 return nativeResponseValue;
27142 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
27144 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
27145 if(!isWasmInitialized) {
27146 throw new Error("initializeWasm() must be awaited first!");
27148 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
27149 // debug statements here
27151 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
27153 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
27154 if(!isWasmInitialized) {
27155 throw new Error("initializeWasm() must be awaited first!");
27157 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
27158 return nativeResponseValue;
27160 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
27162 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
27163 if(!isWasmInitialized) {
27164 throw new Error("initializeWasm() must be awaited first!");
27166 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
27167 // debug statements here
27169 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
27171 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
27172 if(!isWasmInitialized) {
27173 throw new Error("initializeWasm() must be awaited first!");
27175 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
27176 return nativeResponseValue;
27178 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
27180 export function ChainParameters_clone_ptr(arg: bigint): bigint {
27181 if(!isWasmInitialized) {
27182 throw new Error("initializeWasm() must be awaited first!");
27184 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
27185 return nativeResponseValue;
27187 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
27189 export function ChainParameters_clone(orig: bigint): bigint {
27190 if(!isWasmInitialized) {
27191 throw new Error("initializeWasm() must be awaited first!");
27193 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
27194 return nativeResponseValue;
27196 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
27198 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
27199 if(!isWasmInitialized) {
27200 throw new Error("initializeWasm() must be awaited first!");
27202 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
27203 // debug statements here
27205 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
27207 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
27208 if(!isWasmInitialized) {
27209 throw new Error("initializeWasm() must be awaited first!");
27211 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
27212 return nativeResponseValue;
27214 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
27216 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
27217 if(!isWasmInitialized) {
27218 throw new Error("initializeWasm() must be awaited first!");
27220 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
27221 // debug statements here
27223 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
27225 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
27226 if(!isWasmInitialized) {
27227 throw new Error("initializeWasm() must be awaited first!");
27229 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
27230 return nativeResponseValue;
27232 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
27234 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
27235 if(!isWasmInitialized) {
27236 throw new Error("initializeWasm() must be awaited first!");
27238 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
27239 // debug statements here
27241 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
27243 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
27244 if(!isWasmInitialized) {
27245 throw new Error("initializeWasm() must be awaited first!");
27247 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
27248 return nativeResponseValue;
27250 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
27252 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
27253 if(!isWasmInitialized) {
27254 throw new Error("initializeWasm() must be awaited first!");
27256 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
27257 // debug statements here
27259 // 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);
27261 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
27262 if(!isWasmInitialized) {
27263 throw new Error("initializeWasm() must be awaited first!");
27265 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
27266 return nativeResponseValue;
27268 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
27270 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
27271 if(!isWasmInitialized) {
27272 throw new Error("initializeWasm() must be awaited first!");
27274 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
27275 return nativeResponseValue;
27277 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
27279 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
27280 if(!isWasmInitialized) {
27281 throw new Error("initializeWasm() must be awaited first!");
27283 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
27284 return nativeResponseValue;
27286 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
27288 export function ChannelCounterparty_free(this_obj: bigint): void {
27289 if(!isWasmInitialized) {
27290 throw new Error("initializeWasm() must be awaited first!");
27292 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
27293 // debug statements here
27295 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27297 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
27298 if(!isWasmInitialized) {
27299 throw new Error("initializeWasm() must be awaited first!");
27301 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
27302 return nativeResponseValue;
27304 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27306 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
27307 if(!isWasmInitialized) {
27308 throw new Error("initializeWasm() must be awaited first!");
27310 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
27311 // debug statements here
27313 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27315 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
27316 if(!isWasmInitialized) {
27317 throw new Error("initializeWasm() must be awaited first!");
27319 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
27320 return nativeResponseValue;
27322 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
27324 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
27325 if(!isWasmInitialized) {
27326 throw new Error("initializeWasm() must be awaited first!");
27328 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
27329 // debug statements here
27331 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27333 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
27334 if(!isWasmInitialized) {
27335 throw new Error("initializeWasm() must be awaited first!");
27337 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
27338 return nativeResponseValue;
27340 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
27342 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
27343 if(!isWasmInitialized) {
27344 throw new Error("initializeWasm() must be awaited first!");
27346 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
27347 // debug statements here
27349 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27351 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
27352 if(!isWasmInitialized) {
27353 throw new Error("initializeWasm() must be awaited first!");
27355 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
27356 return nativeResponseValue;
27358 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
27360 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
27361 if(!isWasmInitialized) {
27362 throw new Error("initializeWasm() must be awaited first!");
27364 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
27365 // debug statements here
27367 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27369 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
27370 if(!isWasmInitialized) {
27371 throw new Error("initializeWasm() must be awaited first!");
27373 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
27374 return nativeResponseValue;
27376 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27378 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27379 if(!isWasmInitialized) {
27380 throw new Error("initializeWasm() must be awaited first!");
27382 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
27383 // debug statements here
27385 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27387 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
27388 if(!isWasmInitialized) {
27389 throw new Error("initializeWasm() must be awaited first!");
27391 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
27392 return nativeResponseValue;
27394 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27396 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
27397 if(!isWasmInitialized) {
27398 throw new Error("initializeWasm() must be awaited first!");
27400 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
27401 // debug statements here
27403 // 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);
27405 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 {
27406 if(!isWasmInitialized) {
27407 throw new Error("initializeWasm() must be awaited first!");
27409 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);
27410 return nativeResponseValue;
27412 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
27414 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
27415 if(!isWasmInitialized) {
27416 throw new Error("initializeWasm() must be awaited first!");
27418 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
27419 return nativeResponseValue;
27421 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
27423 export function ChannelCounterparty_clone(orig: bigint): bigint {
27424 if(!isWasmInitialized) {
27425 throw new Error("initializeWasm() must be awaited first!");
27427 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
27428 return nativeResponseValue;
27430 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
27432 export function ChannelDetails_free(this_obj: bigint): void {
27433 if(!isWasmInitialized) {
27434 throw new Error("initializeWasm() must be awaited first!");
27436 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
27437 // debug statements here
27439 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
27441 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
27442 if(!isWasmInitialized) {
27443 throw new Error("initializeWasm() must be awaited first!");
27445 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
27446 return nativeResponseValue;
27448 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27450 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
27451 if(!isWasmInitialized) {
27452 throw new Error("initializeWasm() must be awaited first!");
27454 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
27455 // debug statements here
27457 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27459 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
27460 if(!isWasmInitialized) {
27461 throw new Error("initializeWasm() must be awaited first!");
27463 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
27464 return nativeResponseValue;
27466 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
27468 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
27469 if(!isWasmInitialized) {
27470 throw new Error("initializeWasm() must be awaited first!");
27472 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
27473 // debug statements here
27475 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27477 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
27478 if(!isWasmInitialized) {
27479 throw new Error("initializeWasm() must be awaited first!");
27481 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
27482 return nativeResponseValue;
27484 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
27486 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
27487 if(!isWasmInitialized) {
27488 throw new Error("initializeWasm() must be awaited first!");
27490 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
27491 // debug statements here
27493 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27495 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
27496 if(!isWasmInitialized) {
27497 throw new Error("initializeWasm() must be awaited first!");
27499 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
27500 return nativeResponseValue;
27502 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
27504 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
27505 if(!isWasmInitialized) {
27506 throw new Error("initializeWasm() must be awaited first!");
27508 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
27509 // debug statements here
27511 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27513 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
27514 if(!isWasmInitialized) {
27515 throw new Error("initializeWasm() must be awaited first!");
27517 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
27518 return nativeResponseValue;
27520 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27522 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
27523 if(!isWasmInitialized) {
27524 throw new Error("initializeWasm() must be awaited first!");
27526 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
27527 // debug statements here
27529 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27531 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
27532 if(!isWasmInitialized) {
27533 throw new Error("initializeWasm() must be awaited first!");
27535 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
27536 return nativeResponseValue;
27538 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27540 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
27541 if(!isWasmInitialized) {
27542 throw new Error("initializeWasm() must be awaited first!");
27544 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
27545 // debug statements here
27547 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27549 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
27550 if(!isWasmInitialized) {
27551 throw new Error("initializeWasm() must be awaited first!");
27553 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
27554 return nativeResponseValue;
27556 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27558 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
27559 if(!isWasmInitialized) {
27560 throw new Error("initializeWasm() must be awaited first!");
27562 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
27563 // debug statements here
27565 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27567 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
27568 if(!isWasmInitialized) {
27569 throw new Error("initializeWasm() must be awaited first!");
27571 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
27572 return nativeResponseValue;
27574 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
27576 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
27577 if(!isWasmInitialized) {
27578 throw new Error("initializeWasm() must be awaited first!");
27580 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
27581 // debug statements here
27583 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27585 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
27586 if(!isWasmInitialized) {
27587 throw new Error("initializeWasm() must be awaited first!");
27589 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
27590 return nativeResponseValue;
27592 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27594 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
27595 if(!isWasmInitialized) {
27596 throw new Error("initializeWasm() must be awaited first!");
27598 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
27599 // debug statements here
27601 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27603 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
27604 if(!isWasmInitialized) {
27605 throw new Error("initializeWasm() must be awaited first!");
27607 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
27608 return nativeResponseValue;
27610 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
27612 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
27613 if(!isWasmInitialized) {
27614 throw new Error("initializeWasm() must be awaited first!");
27616 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
27617 // debug statements here
27619 // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27621 export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
27622 if(!isWasmInitialized) {
27623 throw new Error("initializeWasm() must be awaited first!");
27625 const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
27626 return nativeResponseValue;
27628 // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
27630 export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
27631 if(!isWasmInitialized) {
27632 throw new Error("initializeWasm() must be awaited first!");
27634 const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
27635 // debug statements here
27637 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27639 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
27640 if(!isWasmInitialized) {
27641 throw new Error("initializeWasm() must be awaited first!");
27643 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
27644 return nativeResponseValue;
27646 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
27648 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
27649 if(!isWasmInitialized) {
27650 throw new Error("initializeWasm() must be awaited first!");
27652 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
27653 // debug statements here
27655 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27657 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
27658 if(!isWasmInitialized) {
27659 throw new Error("initializeWasm() must be awaited first!");
27661 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
27662 return nativeResponseValue;
27664 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
27666 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
27667 if(!isWasmInitialized) {
27668 throw new Error("initializeWasm() must be awaited first!");
27670 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
27671 // debug statements here
27673 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27675 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
27676 if(!isWasmInitialized) {
27677 throw new Error("initializeWasm() must be awaited first!");
27679 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
27680 return nativeResponseValue;
27682 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
27684 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
27685 if(!isWasmInitialized) {
27686 throw new Error("initializeWasm() must be awaited first!");
27688 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
27689 // debug statements here
27691 // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27693 export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
27694 if(!isWasmInitialized) {
27695 throw new Error("initializeWasm() must be awaited first!");
27697 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
27698 return nativeResponseValue;
27700 // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
27702 export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27703 if(!isWasmInitialized) {
27704 throw new Error("initializeWasm() must be awaited first!");
27706 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
27707 // debug statements here
27709 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27711 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
27712 if(!isWasmInitialized) {
27713 throw new Error("initializeWasm() must be awaited first!");
27715 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
27716 return nativeResponseValue;
27718 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
27720 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
27721 if(!isWasmInitialized) {
27722 throw new Error("initializeWasm() must be awaited first!");
27724 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
27725 // debug statements here
27727 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27729 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
27730 if(!isWasmInitialized) {
27731 throw new Error("initializeWasm() must be awaited first!");
27733 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
27734 return nativeResponseValue;
27736 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
27738 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
27739 if(!isWasmInitialized) {
27740 throw new Error("initializeWasm() must be awaited first!");
27742 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
27743 // debug statements here
27745 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27747 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
27748 if(!isWasmInitialized) {
27749 throw new Error("initializeWasm() must be awaited first!");
27751 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
27752 return nativeResponseValue;
27754 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
27756 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
27757 if(!isWasmInitialized) {
27758 throw new Error("initializeWasm() must be awaited first!");
27760 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
27761 // debug statements here
27763 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27765 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
27766 if(!isWasmInitialized) {
27767 throw new Error("initializeWasm() must be awaited first!");
27769 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
27770 return nativeResponseValue;
27772 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
27774 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
27775 if(!isWasmInitialized) {
27776 throw new Error("initializeWasm() must be awaited first!");
27778 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
27779 // debug statements here
27781 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27783 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
27784 if(!isWasmInitialized) {
27785 throw new Error("initializeWasm() must be awaited first!");
27787 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
27788 return nativeResponseValue;
27790 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
27792 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
27793 if(!isWasmInitialized) {
27794 throw new Error("initializeWasm() must be awaited first!");
27796 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
27797 // debug statements here
27799 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27801 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
27802 if(!isWasmInitialized) {
27803 throw new Error("initializeWasm() must be awaited first!");
27805 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
27806 return nativeResponseValue;
27808 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
27810 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
27811 if(!isWasmInitialized) {
27812 throw new Error("initializeWasm() must be awaited first!");
27814 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
27815 // debug statements here
27817 // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27819 export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
27820 if(!isWasmInitialized) {
27821 throw new Error("initializeWasm() must be awaited first!");
27823 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
27824 return nativeResponseValue;
27826 // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
27828 export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
27829 if(!isWasmInitialized) {
27830 throw new Error("initializeWasm() must be awaited first!");
27832 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
27833 // debug statements here
27835 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27837 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
27838 if(!isWasmInitialized) {
27839 throw new Error("initializeWasm() must be awaited first!");
27841 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
27842 return nativeResponseValue;
27844 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
27846 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
27847 if(!isWasmInitialized) {
27848 throw new Error("initializeWasm() must be awaited first!");
27850 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
27851 // debug statements here
27853 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27855 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
27856 if(!isWasmInitialized) {
27857 throw new Error("initializeWasm() must be awaited first!");
27859 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
27860 return nativeResponseValue;
27862 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
27864 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
27865 if(!isWasmInitialized) {
27866 throw new Error("initializeWasm() must be awaited first!");
27868 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
27869 // debug statements here
27871 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27873 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
27874 if(!isWasmInitialized) {
27875 throw new Error("initializeWasm() must be awaited first!");
27877 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
27878 return nativeResponseValue;
27880 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27882 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27883 if(!isWasmInitialized) {
27884 throw new Error("initializeWasm() must be awaited first!");
27886 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
27887 // debug statements here
27889 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27891 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
27892 if(!isWasmInitialized) {
27893 throw new Error("initializeWasm() must be awaited first!");
27895 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
27896 return nativeResponseValue;
27898 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27900 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
27901 if(!isWasmInitialized) {
27902 throw new Error("initializeWasm() must be awaited first!");
27904 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
27905 // debug statements here
27907 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27909 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
27910 if(!isWasmInitialized) {
27911 throw new Error("initializeWasm() must be awaited first!");
27913 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
27914 return nativeResponseValue;
27916 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
27918 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
27919 if(!isWasmInitialized) {
27920 throw new Error("initializeWasm() must be awaited first!");
27922 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
27923 // debug statements here
27925 // 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);
27927 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 {
27928 if(!isWasmInitialized) {
27929 throw new Error("initializeWasm() must be awaited first!");
27931 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);
27932 return nativeResponseValue;
27934 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
27936 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
27937 if(!isWasmInitialized) {
27938 throw new Error("initializeWasm() must be awaited first!");
27940 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
27941 return nativeResponseValue;
27943 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
27945 export function ChannelDetails_clone(orig: bigint): bigint {
27946 if(!isWasmInitialized) {
27947 throw new Error("initializeWasm() must be awaited first!");
27949 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
27950 return nativeResponseValue;
27952 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
27954 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
27955 if(!isWasmInitialized) {
27956 throw new Error("initializeWasm() must be awaited first!");
27958 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
27959 return nativeResponseValue;
27961 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
27963 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
27964 if(!isWasmInitialized) {
27965 throw new Error("initializeWasm() must be awaited first!");
27967 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
27968 return nativeResponseValue;
27970 // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
27972 export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
27973 if(!isWasmInitialized) {
27974 throw new Error("initializeWasm() must be awaited first!");
27976 const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
27977 return nativeResponseValue;
27979 // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
27981 export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
27982 if(!isWasmInitialized) {
27983 throw new Error("initializeWasm() must be awaited first!");
27985 const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
27986 return nativeResponseValue;
27988 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
27990 export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
27991 if(!isWasmInitialized) {
27992 throw new Error("initializeWasm() must be awaited first!");
27994 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
27995 return nativeResponseValue;
27997 // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
27999 export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
28000 if(!isWasmInitialized) {
28001 throw new Error("initializeWasm() must be awaited first!");
28003 const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
28004 return nativeResponseValue;
28006 // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
28008 export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
28009 if(!isWasmInitialized) {
28010 throw new Error("initializeWasm() must be awaited first!");
28012 const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
28013 return nativeResponseValue;
28015 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
28017 export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
28018 if(!isWasmInitialized) {
28019 throw new Error("initializeWasm() must be awaited first!");
28021 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
28022 return nativeResponseValue;
28024 // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
28026 export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
28027 if(!isWasmInitialized) {
28028 throw new Error("initializeWasm() must be awaited first!");
28030 const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
28031 return nativeResponseValue;
28033 // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
28035 export function RecentPaymentDetails_free(this_ptr: bigint): void {
28036 if(!isWasmInitialized) {
28037 throw new Error("initializeWasm() must be awaited first!");
28039 const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
28040 // debug statements here
28042 // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
28044 export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
28045 if(!isWasmInitialized) {
28046 throw new Error("initializeWasm() must be awaited first!");
28048 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
28049 return nativeResponseValue;
28051 // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
28053 export function RecentPaymentDetails_clone(orig: bigint): bigint {
28054 if(!isWasmInitialized) {
28055 throw new Error("initializeWasm() must be awaited first!");
28057 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
28058 return nativeResponseValue;
28060 // struct LDKRecentPaymentDetails RecentPaymentDetails_awaiting_invoice(struct LDKThirtyTwoBytes payment_id);
28062 export function RecentPaymentDetails_awaiting_invoice(payment_id: number): bigint {
28063 if(!isWasmInitialized) {
28064 throw new Error("initializeWasm() must be awaited first!");
28066 const nativeResponseValue = wasm.TS_RecentPaymentDetails_awaiting_invoice(payment_id);
28067 return nativeResponseValue;
28069 // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
28071 export function RecentPaymentDetails_pending(payment_id: number, payment_hash: number, total_msat: bigint): bigint {
28072 if(!isWasmInitialized) {
28073 throw new Error("initializeWasm() must be awaited first!");
28075 const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_id, payment_hash, total_msat);
28076 return nativeResponseValue;
28078 // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash);
28080 export function RecentPaymentDetails_fulfilled(payment_id: number, payment_hash: bigint): bigint {
28081 if(!isWasmInitialized) {
28082 throw new Error("initializeWasm() must be awaited first!");
28084 const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_id, payment_hash);
28085 return nativeResponseValue;
28087 // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
28089 export function RecentPaymentDetails_abandoned(payment_id: number, payment_hash: number): bigint {
28090 if(!isWasmInitialized) {
28091 throw new Error("initializeWasm() must be awaited first!");
28093 const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_id, payment_hash);
28094 return nativeResponseValue;
28096 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
28098 export function PhantomRouteHints_free(this_obj: bigint): void {
28099 if(!isWasmInitialized) {
28100 throw new Error("initializeWasm() must be awaited first!");
28102 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
28103 // debug statements here
28105 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
28107 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
28108 if(!isWasmInitialized) {
28109 throw new Error("initializeWasm() must be awaited first!");
28111 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
28112 return nativeResponseValue;
28114 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
28116 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
28117 if(!isWasmInitialized) {
28118 throw new Error("initializeWasm() must be awaited first!");
28120 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
28121 // debug statements here
28123 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
28125 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
28126 if(!isWasmInitialized) {
28127 throw new Error("initializeWasm() must be awaited first!");
28129 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
28130 return nativeResponseValue;
28132 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
28134 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
28135 if(!isWasmInitialized) {
28136 throw new Error("initializeWasm() must be awaited first!");
28138 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
28139 // debug statements here
28141 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
28143 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
28144 if(!isWasmInitialized) {
28145 throw new Error("initializeWasm() must be awaited first!");
28147 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
28148 return nativeResponseValue;
28150 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28152 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
28153 if(!isWasmInitialized) {
28154 throw new Error("initializeWasm() must be awaited first!");
28156 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
28157 // debug statements here
28159 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
28161 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
28162 if(!isWasmInitialized) {
28163 throw new Error("initializeWasm() must be awaited first!");
28165 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
28166 return nativeResponseValue;
28168 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
28170 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
28171 if(!isWasmInitialized) {
28172 throw new Error("initializeWasm() must be awaited first!");
28174 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
28175 return nativeResponseValue;
28177 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
28179 export function PhantomRouteHints_clone(orig: bigint): bigint {
28180 if(!isWasmInitialized) {
28181 throw new Error("initializeWasm() must be awaited first!");
28183 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
28184 return nativeResponseValue;
28186 // 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);
28188 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 {
28189 if(!isWasmInitialized) {
28190 throw new Error("initializeWasm() must be awaited first!");
28192 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
28193 return nativeResponseValue;
28195 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
28197 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
28198 if(!isWasmInitialized) {
28199 throw new Error("initializeWasm() must be awaited first!");
28201 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
28202 return nativeResponseValue;
28204 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesAPIErrorZ 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);
28206 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 {
28207 if(!isWasmInitialized) {
28208 throw new Error("initializeWasm() must be awaited first!");
28210 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
28211 return nativeResponseValue;
28213 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
28215 export function ChannelManager_list_channels(this_arg: bigint): number {
28216 if(!isWasmInitialized) {
28217 throw new Error("initializeWasm() must be awaited first!");
28219 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
28220 return nativeResponseValue;
28222 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
28224 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
28225 if(!isWasmInitialized) {
28226 throw new Error("initializeWasm() must be awaited first!");
28228 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
28229 return nativeResponseValue;
28231 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
28233 export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
28234 if(!isWasmInitialized) {
28235 throw new Error("initializeWasm() must be awaited first!");
28237 const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
28238 return nativeResponseValue;
28240 // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
28242 export function ChannelManager_list_recent_payments(this_arg: bigint): number {
28243 if(!isWasmInitialized) {
28244 throw new Error("initializeWasm() must be awaited first!");
28246 const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
28247 return nativeResponseValue;
28249 // 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);
28251 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
28252 if(!isWasmInitialized) {
28253 throw new Error("initializeWasm() must be awaited first!");
28255 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
28256 return nativeResponseValue;
28258 // 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);
28260 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 {
28261 if(!isWasmInitialized) {
28262 throw new Error("initializeWasm() must be awaited first!");
28264 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);
28265 return nativeResponseValue;
28267 // 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);
28269 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
28270 if(!isWasmInitialized) {
28271 throw new Error("initializeWasm() must be awaited first!");
28273 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
28274 return nativeResponseValue;
28276 // 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);
28278 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
28279 if(!isWasmInitialized) {
28280 throw new Error("initializeWasm() must be awaited first!");
28282 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
28283 return nativeResponseValue;
28285 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
28287 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
28288 if(!isWasmInitialized) {
28289 throw new Error("initializeWasm() must be awaited first!");
28291 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
28292 // debug statements here
28294 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
28296 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
28297 if(!isWasmInitialized) {
28298 throw new Error("initializeWasm() must be awaited first!");
28300 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
28301 // debug statements here
28303 // 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);
28305 export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
28306 if(!isWasmInitialized) {
28307 throw new Error("initializeWasm() must be awaited first!");
28309 const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
28310 return nativeResponseValue;
28312 // 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);
28314 export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
28315 if(!isWasmInitialized) {
28316 throw new Error("initializeWasm() must be awaited first!");
28318 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
28319 return nativeResponseValue;
28321 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
28323 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
28324 if(!isWasmInitialized) {
28325 throw new Error("initializeWasm() must be awaited first!");
28327 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
28328 // debug statements here
28330 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
28332 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
28333 if(!isWasmInitialized) {
28334 throw new Error("initializeWasm() must be awaited first!");
28336 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
28337 return nativeResponseValue;
28339 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
28341 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 {
28342 if(!isWasmInitialized) {
28343 throw new Error("initializeWasm() must be awaited first!");
28345 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
28346 return nativeResponseValue;
28348 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
28350 export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
28351 if(!isWasmInitialized) {
28352 throw new Error("initializeWasm() must be awaited first!");
28354 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
28355 return nativeResponseValue;
28357 // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_spontaneous_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, uint64_t amount_msat, uint32_t final_cltv_expiry_delta, struct LDKCOption_u64Z liquidity_limit_multiplier);
28359 export function ChannelManager_send_spontaneous_preflight_probes(this_arg: bigint, node_id: number, amount_msat: bigint, final_cltv_expiry_delta: number, liquidity_limit_multiplier: bigint): bigint {
28360 if(!isWasmInitialized) {
28361 throw new Error("initializeWasm() must be awaited first!");
28363 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_preflight_probes(this_arg, node_id, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier);
28364 return nativeResponseValue;
28366 // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKRouteParameters route_params, struct LDKCOption_u64Z liquidity_limit_multiplier);
28368 export function ChannelManager_send_preflight_probes(this_arg: bigint, route_params: bigint, liquidity_limit_multiplier: bigint): bigint {
28369 if(!isWasmInitialized) {
28370 throw new Error("initializeWasm() must be awaited first!");
28372 const nativeResponseValue = wasm.TS_ChannelManager_send_preflight_probes(this_arg, route_params, liquidity_limit_multiplier);
28373 return nativeResponseValue;
28375 // 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);
28377 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
28378 if(!isWasmInitialized) {
28379 throw new Error("initializeWasm() must be awaited first!");
28381 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
28382 return nativeResponseValue;
28384 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_batch_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ temporary_channels, struct LDKTransaction funding_transaction);
28386 export function ChannelManager_batch_funding_transaction_generated(this_arg: bigint, temporary_channels: number, funding_transaction: number): bigint {
28387 if(!isWasmInitialized) {
28388 throw new Error("initializeWasm() must be awaited first!");
28390 const nativeResponseValue = wasm.TS_ChannelManager_batch_funding_transaction_generated(this_arg, temporary_channels, funding_transaction);
28391 return nativeResponseValue;
28393 // 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);
28395 export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
28396 if(!isWasmInitialized) {
28397 throw new Error("initializeWasm() must be awaited first!");
28399 const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
28400 return nativeResponseValue;
28402 // 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);
28404 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
28405 if(!isWasmInitialized) {
28406 throw new Error("initializeWasm() must be awaited first!");
28408 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
28409 return nativeResponseValue;
28411 // 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);
28413 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 {
28414 if(!isWasmInitialized) {
28415 throw new Error("initializeWasm() must be awaited first!");
28417 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
28418 return nativeResponseValue;
28420 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
28422 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
28423 if(!isWasmInitialized) {
28424 throw new Error("initializeWasm() must be awaited first!");
28426 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
28427 return nativeResponseValue;
28429 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
28431 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
28432 if(!isWasmInitialized) {
28433 throw new Error("initializeWasm() must be awaited first!");
28435 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
28436 // debug statements here
28438 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
28440 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
28441 if(!isWasmInitialized) {
28442 throw new Error("initializeWasm() must be awaited first!");
28444 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
28445 // debug statements here
28447 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
28449 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
28450 if(!isWasmInitialized) {
28451 throw new Error("initializeWasm() must be awaited first!");
28453 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
28454 // debug statements here
28456 // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKFailureCode failure_code);
28458 export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: bigint): void {
28459 if(!isWasmInitialized) {
28460 throw new Error("initializeWasm() must be awaited first!");
28462 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
28463 // debug statements here
28465 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
28467 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
28468 if(!isWasmInitialized) {
28469 throw new Error("initializeWasm() must be awaited first!");
28471 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
28472 // debug statements here
28474 // void ChannelManager_claim_funds_with_known_custom_tlvs(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
28476 export function ChannelManager_claim_funds_with_known_custom_tlvs(this_arg: bigint, payment_preimage: number): void {
28477 if(!isWasmInitialized) {
28478 throw new Error("initializeWasm() must be awaited first!");
28480 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds_with_known_custom_tlvs(this_arg, payment_preimage);
28481 // debug statements here
28483 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
28485 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
28486 if(!isWasmInitialized) {
28487 throw new Error("initializeWasm() must be awaited first!");
28489 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
28490 return nativeResponseValue;
28492 // 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);
28494 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
28495 if(!isWasmInitialized) {
28496 throw new Error("initializeWasm() must be awaited first!");
28498 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
28499 return nativeResponseValue;
28501 // 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);
28503 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 {
28504 if(!isWasmInitialized) {
28505 throw new Error("initializeWasm() must be awaited first!");
28507 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
28508 return nativeResponseValue;
28510 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ 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);
28512 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 {
28513 if(!isWasmInitialized) {
28514 throw new Error("initializeWasm() must be awaited first!");
28516 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
28517 return nativeResponseValue;
28519 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ 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);
28521 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 {
28522 if(!isWasmInitialized) {
28523 throw new Error("initializeWasm() must be awaited first!");
28525 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);
28526 return nativeResponseValue;
28528 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesAPIErrorZ ChannelManager_get_payment_preimage(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
28530 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
28531 if(!isWasmInitialized) {
28532 throw new Error("initializeWasm() must be awaited first!");
28534 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
28535 return nativeResponseValue;
28537 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
28539 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
28540 if(!isWasmInitialized) {
28541 throw new Error("initializeWasm() must be awaited first!");
28543 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
28544 return nativeResponseValue;
28546 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
28548 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
28549 if(!isWasmInitialized) {
28550 throw new Error("initializeWasm() must be awaited first!");
28552 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
28553 return nativeResponseValue;
28555 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
28557 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
28558 if(!isWasmInitialized) {
28559 throw new Error("initializeWasm() must be awaited first!");
28561 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
28562 return nativeResponseValue;
28564 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
28566 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
28567 if(!isWasmInitialized) {
28568 throw new Error("initializeWasm() must be awaited first!");
28570 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
28571 return nativeResponseValue;
28573 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
28575 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
28576 if(!isWasmInitialized) {
28577 throw new Error("initializeWasm() must be awaited first!");
28579 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
28580 return nativeResponseValue;
28582 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
28584 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
28585 if(!isWasmInitialized) {
28586 throw new Error("initializeWasm() must be awaited first!");
28588 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
28589 return nativeResponseValue;
28591 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
28593 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
28594 if(!isWasmInitialized) {
28595 throw new Error("initializeWasm() must be awaited first!");
28597 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
28598 return nativeResponseValue;
28600 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
28602 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
28603 if(!isWasmInitialized) {
28604 throw new Error("initializeWasm() must be awaited first!");
28606 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
28607 return nativeResponseValue;
28609 // MUST_USE_RES struct LDKFuture ChannelManager_get_event_or_persistence_needed_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
28611 export function ChannelManager_get_event_or_persistence_needed_future(this_arg: bigint): bigint {
28612 if(!isWasmInitialized) {
28613 throw new Error("initializeWasm() must be awaited first!");
28615 const nativeResponseValue = wasm.TS_ChannelManager_get_event_or_persistence_needed_future(this_arg);
28616 return nativeResponseValue;
28618 // MUST_USE_RES bool ChannelManager_get_and_clear_needs_persistence(const struct LDKChannelManager *NONNULL_PTR this_arg);
28620 export function ChannelManager_get_and_clear_needs_persistence(this_arg: bigint): boolean {
28621 if(!isWasmInitialized) {
28622 throw new Error("initializeWasm() must be awaited first!");
28624 const nativeResponseValue = wasm.TS_ChannelManager_get_and_clear_needs_persistence(this_arg);
28625 return nativeResponseValue;
28627 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
28629 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
28630 if(!isWasmInitialized) {
28631 throw new Error("initializeWasm() must be awaited first!");
28633 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
28634 return nativeResponseValue;
28636 // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
28638 export function ChannelManager_node_features(this_arg: bigint): bigint {
28639 if(!isWasmInitialized) {
28640 throw new Error("initializeWasm() must be awaited first!");
28642 const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
28643 return nativeResponseValue;
28645 // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
28647 export function ChannelManager_channel_features(this_arg: bigint): bigint {
28648 if(!isWasmInitialized) {
28649 throw new Error("initializeWasm() must be awaited first!");
28651 const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
28652 return nativeResponseValue;
28654 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
28656 export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
28657 if(!isWasmInitialized) {
28658 throw new Error("initializeWasm() must be awaited first!");
28660 const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
28661 return nativeResponseValue;
28663 // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
28665 export function ChannelManager_init_features(this_arg: bigint): bigint {
28666 if(!isWasmInitialized) {
28667 throw new Error("initializeWasm() must be awaited first!");
28669 const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
28670 return nativeResponseValue;
28672 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
28674 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
28675 if(!isWasmInitialized) {
28676 throw new Error("initializeWasm() must be awaited first!");
28678 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
28679 return nativeResponseValue;
28681 // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
28683 export function provided_init_features(config: bigint): bigint {
28684 if(!isWasmInitialized) {
28685 throw new Error("initializeWasm() must be awaited first!");
28687 const nativeResponseValue = wasm.TS_provided_init_features(config);
28688 return nativeResponseValue;
28690 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
28692 export function CounterpartyForwardingInfo_write(obj: bigint): number {
28693 if(!isWasmInitialized) {
28694 throw new Error("initializeWasm() must be awaited first!");
28696 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
28697 return nativeResponseValue;
28699 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
28701 export function CounterpartyForwardingInfo_read(ser: number): bigint {
28702 if(!isWasmInitialized) {
28703 throw new Error("initializeWasm() must be awaited first!");
28705 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
28706 return nativeResponseValue;
28708 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
28710 export function ChannelCounterparty_write(obj: bigint): number {
28711 if(!isWasmInitialized) {
28712 throw new Error("initializeWasm() must be awaited first!");
28714 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
28715 return nativeResponseValue;
28717 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
28719 export function ChannelCounterparty_read(ser: number): bigint {
28720 if(!isWasmInitialized) {
28721 throw new Error("initializeWasm() must be awaited first!");
28723 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
28724 return nativeResponseValue;
28726 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
28728 export function ChannelDetails_write(obj: bigint): number {
28729 if(!isWasmInitialized) {
28730 throw new Error("initializeWasm() must be awaited first!");
28732 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
28733 return nativeResponseValue;
28735 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
28737 export function ChannelDetails_read(ser: number): bigint {
28738 if(!isWasmInitialized) {
28739 throw new Error("initializeWasm() must be awaited first!");
28741 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
28742 return nativeResponseValue;
28744 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
28746 export function PhantomRouteHints_write(obj: bigint): number {
28747 if(!isWasmInitialized) {
28748 throw new Error("initializeWasm() must be awaited first!");
28750 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
28751 return nativeResponseValue;
28753 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
28755 export function PhantomRouteHints_read(ser: number): bigint {
28756 if(!isWasmInitialized) {
28757 throw new Error("initializeWasm() must be awaited first!");
28759 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
28760 return nativeResponseValue;
28762 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
28764 export function ChannelManager_write(obj: bigint): number {
28765 if(!isWasmInitialized) {
28766 throw new Error("initializeWasm() must be awaited first!");
28768 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
28769 return nativeResponseValue;
28771 // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
28773 export function ChannelShutdownState_write(obj: bigint): number {
28774 if(!isWasmInitialized) {
28775 throw new Error("initializeWasm() must be awaited first!");
28777 const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
28778 return nativeResponseValue;
28780 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
28782 export function ChannelShutdownState_read(ser: number): bigint {
28783 if(!isWasmInitialized) {
28784 throw new Error("initializeWasm() must be awaited first!");
28786 const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
28787 return nativeResponseValue;
28789 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
28791 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
28792 if(!isWasmInitialized) {
28793 throw new Error("initializeWasm() must be awaited first!");
28795 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
28796 // debug statements here
28798 // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28800 export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
28801 if(!isWasmInitialized) {
28802 throw new Error("initializeWasm() must be awaited first!");
28804 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
28805 return nativeResponseValue;
28807 // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
28809 export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
28810 if(!isWasmInitialized) {
28811 throw new Error("initializeWasm() must be awaited first!");
28813 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
28814 // debug statements here
28816 // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28818 export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
28819 if(!isWasmInitialized) {
28820 throw new Error("initializeWasm() must be awaited first!");
28822 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
28823 return nativeResponseValue;
28825 // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
28827 export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
28828 if(!isWasmInitialized) {
28829 throw new Error("initializeWasm() must be awaited first!");
28831 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
28832 // debug statements here
28834 // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28836 export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
28837 if(!isWasmInitialized) {
28838 throw new Error("initializeWasm() must be awaited first!");
28840 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
28841 return nativeResponseValue;
28843 // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
28845 export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
28846 if(!isWasmInitialized) {
28847 throw new Error("initializeWasm() must be awaited first!");
28849 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
28850 // debug statements here
28852 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28854 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
28855 if(!isWasmInitialized) {
28856 throw new Error("initializeWasm() must be awaited first!");
28858 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
28859 return nativeResponseValue;
28861 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
28863 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
28864 if(!isWasmInitialized) {
28865 throw new Error("initializeWasm() must be awaited first!");
28867 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
28868 // debug statements here
28870 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28872 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
28873 if(!isWasmInitialized) {
28874 throw new Error("initializeWasm() must be awaited first!");
28876 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
28877 return nativeResponseValue;
28879 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
28881 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
28882 if(!isWasmInitialized) {
28883 throw new Error("initializeWasm() must be awaited first!");
28885 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
28886 // debug statements here
28888 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28890 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
28891 if(!isWasmInitialized) {
28892 throw new Error("initializeWasm() must be awaited first!");
28894 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
28895 return nativeResponseValue;
28897 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
28899 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
28900 if(!isWasmInitialized) {
28901 throw new Error("initializeWasm() must be awaited first!");
28903 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
28904 // debug statements here
28906 // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28908 export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
28909 if(!isWasmInitialized) {
28910 throw new Error("initializeWasm() must be awaited first!");
28912 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
28913 return nativeResponseValue;
28915 // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
28917 export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
28918 if(!isWasmInitialized) {
28919 throw new Error("initializeWasm() must be awaited first!");
28921 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
28922 // debug statements here
28924 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28926 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
28927 if(!isWasmInitialized) {
28928 throw new Error("initializeWasm() must be awaited first!");
28930 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
28931 return nativeResponseValue;
28933 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
28935 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
28936 if(!isWasmInitialized) {
28937 throw new Error("initializeWasm() must be awaited first!");
28939 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
28940 // debug statements here
28942 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
28944 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
28945 if(!isWasmInitialized) {
28946 throw new Error("initializeWasm() must be awaited first!");
28948 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
28949 return nativeResponseValue;
28951 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
28953 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
28954 if(!isWasmInitialized) {
28955 throw new Error("initializeWasm() must be awaited first!");
28957 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
28958 // debug statements here
28960 // 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);
28962 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 {
28963 if(!isWasmInitialized) {
28964 throw new Error("initializeWasm() must be awaited first!");
28966 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
28967 return nativeResponseValue;
28969 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
28971 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser: number, arg: bigint): bigint {
28972 if(!isWasmInitialized) {
28973 throw new Error("initializeWasm() must be awaited first!");
28975 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser, arg);
28976 return nativeResponseValue;
28978 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
28980 export function ExpandedKey_free(this_obj: bigint): void {
28981 if(!isWasmInitialized) {
28982 throw new Error("initializeWasm() must be awaited first!");
28984 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
28985 // debug statements here
28987 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
28989 export function ExpandedKey_new(key_material: number): bigint {
28990 if(!isWasmInitialized) {
28991 throw new Error("initializeWasm() must be awaited first!");
28993 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
28994 return nativeResponseValue;
28996 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ 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);
28998 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 {
28999 if(!isWasmInitialized) {
29000 throw new Error("initializeWasm() must be awaited first!");
29002 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, entropy_source, current_time, min_final_cltv_expiry_delta);
29003 return nativeResponseValue;
29005 // struct LDKCResult_ThirtyTwoBytesNoneZ 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);
29007 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 {
29008 if(!isWasmInitialized) {
29009 throw new Error("initializeWasm() must be awaited first!");
29011 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta);
29012 return nativeResponseValue;
29014 // void DecodeError_free(struct LDKDecodeError this_ptr);
29016 export function DecodeError_free(this_ptr: bigint): void {
29017 if(!isWasmInitialized) {
29018 throw new Error("initializeWasm() must be awaited first!");
29020 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
29021 // debug statements here
29023 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
29025 export function DecodeError_clone_ptr(arg: bigint): bigint {
29026 if(!isWasmInitialized) {
29027 throw new Error("initializeWasm() must be awaited first!");
29029 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
29030 return nativeResponseValue;
29032 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
29034 export function DecodeError_clone(orig: bigint): bigint {
29035 if(!isWasmInitialized) {
29036 throw new Error("initializeWasm() must be awaited first!");
29038 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
29039 return nativeResponseValue;
29041 // struct LDKDecodeError DecodeError_unknown_version(void);
29043 export function DecodeError_unknown_version(): bigint {
29044 if(!isWasmInitialized) {
29045 throw new Error("initializeWasm() must be awaited first!");
29047 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
29048 return nativeResponseValue;
29050 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
29052 export function DecodeError_unknown_required_feature(): bigint {
29053 if(!isWasmInitialized) {
29054 throw new Error("initializeWasm() must be awaited first!");
29056 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
29057 return nativeResponseValue;
29059 // struct LDKDecodeError DecodeError_invalid_value(void);
29061 export function DecodeError_invalid_value(): bigint {
29062 if(!isWasmInitialized) {
29063 throw new Error("initializeWasm() must be awaited first!");
29065 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
29066 return nativeResponseValue;
29068 // struct LDKDecodeError DecodeError_short_read(void);
29070 export function DecodeError_short_read(): bigint {
29071 if(!isWasmInitialized) {
29072 throw new Error("initializeWasm() must be awaited first!");
29074 const nativeResponseValue = wasm.TS_DecodeError_short_read();
29075 return nativeResponseValue;
29077 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
29079 export function DecodeError_bad_length_descriptor(): bigint {
29080 if(!isWasmInitialized) {
29081 throw new Error("initializeWasm() must be awaited first!");
29083 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
29084 return nativeResponseValue;
29086 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
29088 export function DecodeError_io(a: IOError): bigint {
29089 if(!isWasmInitialized) {
29090 throw new Error("initializeWasm() must be awaited first!");
29092 const nativeResponseValue = wasm.TS_DecodeError_io(a);
29093 return nativeResponseValue;
29095 // struct LDKDecodeError DecodeError_unsupported_compression(void);
29097 export function DecodeError_unsupported_compression(): bigint {
29098 if(!isWasmInitialized) {
29099 throw new Error("initializeWasm() must be awaited first!");
29101 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
29102 return nativeResponseValue;
29104 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
29106 export function DecodeError_eq(a: bigint, b: bigint): boolean {
29107 if(!isWasmInitialized) {
29108 throw new Error("initializeWasm() must be awaited first!");
29110 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
29111 return nativeResponseValue;
29113 // void Init_free(struct LDKInit this_obj);
29115 export function Init_free(this_obj: bigint): void {
29116 if(!isWasmInitialized) {
29117 throw new Error("initializeWasm() must be awaited first!");
29119 const nativeResponseValue = wasm.TS_Init_free(this_obj);
29120 // debug statements here
29122 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
29124 export function Init_get_features(this_ptr: bigint): bigint {
29125 if(!isWasmInitialized) {
29126 throw new Error("initializeWasm() must be awaited first!");
29128 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
29129 return nativeResponseValue;
29131 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
29133 export function Init_set_features(this_ptr: bigint, val: bigint): void {
29134 if(!isWasmInitialized) {
29135 throw new Error("initializeWasm() must be awaited first!");
29137 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
29138 // debug statements here
29140 // struct LDKCOption_CVec_ThirtyTwoBytesZZ Init_get_networks(const struct LDKInit *NONNULL_PTR this_ptr);
29142 export function Init_get_networks(this_ptr: bigint): bigint {
29143 if(!isWasmInitialized) {
29144 throw new Error("initializeWasm() must be awaited first!");
29146 const nativeResponseValue = wasm.TS_Init_get_networks(this_ptr);
29147 return nativeResponseValue;
29149 // void Init_set_networks(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_CVec_ThirtyTwoBytesZZ val);
29151 export function Init_set_networks(this_ptr: bigint, val: bigint): void {
29152 if(!isWasmInitialized) {
29153 throw new Error("initializeWasm() must be awaited first!");
29155 const nativeResponseValue = wasm.TS_Init_set_networks(this_ptr, val);
29156 // debug statements here
29158 // struct LDKCOption_SocketAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
29160 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
29161 if(!isWasmInitialized) {
29162 throw new Error("initializeWasm() must be awaited first!");
29164 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
29165 return nativeResponseValue;
29167 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_SocketAddressZ val);
29169 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
29170 if(!isWasmInitialized) {
29171 throw new Error("initializeWasm() must be awaited first!");
29173 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
29174 // debug statements here
29176 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_CVec_ThirtyTwoBytesZZ networks_arg, struct LDKCOption_SocketAddressZ remote_network_address_arg);
29178 export function Init_new(features_arg: bigint, networks_arg: bigint, remote_network_address_arg: bigint): bigint {
29179 if(!isWasmInitialized) {
29180 throw new Error("initializeWasm() must be awaited first!");
29182 const nativeResponseValue = wasm.TS_Init_new(features_arg, networks_arg, remote_network_address_arg);
29183 return nativeResponseValue;
29185 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
29187 export function Init_clone_ptr(arg: bigint): bigint {
29188 if(!isWasmInitialized) {
29189 throw new Error("initializeWasm() must be awaited first!");
29191 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
29192 return nativeResponseValue;
29194 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
29196 export function Init_clone(orig: bigint): bigint {
29197 if(!isWasmInitialized) {
29198 throw new Error("initializeWasm() must be awaited first!");
29200 const nativeResponseValue = wasm.TS_Init_clone(orig);
29201 return nativeResponseValue;
29203 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
29205 export function Init_eq(a: bigint, b: bigint): boolean {
29206 if(!isWasmInitialized) {
29207 throw new Error("initializeWasm() must be awaited first!");
29209 const nativeResponseValue = wasm.TS_Init_eq(a, b);
29210 return nativeResponseValue;
29212 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
29214 export function ErrorMessage_free(this_obj: bigint): void {
29215 if(!isWasmInitialized) {
29216 throw new Error("initializeWasm() must be awaited first!");
29218 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
29219 // debug statements here
29221 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
29223 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
29224 if(!isWasmInitialized) {
29225 throw new Error("initializeWasm() must be awaited first!");
29227 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
29228 return nativeResponseValue;
29230 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29232 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
29233 if(!isWasmInitialized) {
29234 throw new Error("initializeWasm() must be awaited first!");
29236 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
29237 // debug statements here
29239 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
29241 export function ErrorMessage_get_data(this_ptr: bigint): number {
29242 if(!isWasmInitialized) {
29243 throw new Error("initializeWasm() must be awaited first!");
29245 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
29246 return nativeResponseValue;
29248 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
29250 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
29251 if(!isWasmInitialized) {
29252 throw new Error("initializeWasm() must be awaited first!");
29254 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
29255 // debug statements here
29257 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
29259 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
29260 if(!isWasmInitialized) {
29261 throw new Error("initializeWasm() must be awaited first!");
29263 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
29264 return nativeResponseValue;
29266 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
29268 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
29269 if(!isWasmInitialized) {
29270 throw new Error("initializeWasm() must be awaited first!");
29272 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
29273 return nativeResponseValue;
29275 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
29277 export function ErrorMessage_clone(orig: bigint): bigint {
29278 if(!isWasmInitialized) {
29279 throw new Error("initializeWasm() must be awaited first!");
29281 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
29282 return nativeResponseValue;
29284 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
29286 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
29287 if(!isWasmInitialized) {
29288 throw new Error("initializeWasm() must be awaited first!");
29290 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
29291 return nativeResponseValue;
29293 // void WarningMessage_free(struct LDKWarningMessage this_obj);
29295 export function WarningMessage_free(this_obj: bigint): void {
29296 if(!isWasmInitialized) {
29297 throw new Error("initializeWasm() must be awaited first!");
29299 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
29300 // debug statements here
29302 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
29304 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
29305 if(!isWasmInitialized) {
29306 throw new Error("initializeWasm() must be awaited first!");
29308 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
29309 return nativeResponseValue;
29311 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29313 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
29314 if(!isWasmInitialized) {
29315 throw new Error("initializeWasm() must be awaited first!");
29317 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
29318 // debug statements here
29320 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
29322 export function WarningMessage_get_data(this_ptr: bigint): number {
29323 if(!isWasmInitialized) {
29324 throw new Error("initializeWasm() must be awaited first!");
29326 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
29327 return nativeResponseValue;
29329 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
29331 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
29332 if(!isWasmInitialized) {
29333 throw new Error("initializeWasm() must be awaited first!");
29335 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
29336 // debug statements here
29338 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
29340 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
29341 if(!isWasmInitialized) {
29342 throw new Error("initializeWasm() must be awaited first!");
29344 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
29345 return nativeResponseValue;
29347 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
29349 export function WarningMessage_clone_ptr(arg: bigint): bigint {
29350 if(!isWasmInitialized) {
29351 throw new Error("initializeWasm() must be awaited first!");
29353 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
29354 return nativeResponseValue;
29356 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
29358 export function WarningMessage_clone(orig: bigint): bigint {
29359 if(!isWasmInitialized) {
29360 throw new Error("initializeWasm() must be awaited first!");
29362 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
29363 return nativeResponseValue;
29365 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
29367 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
29368 if(!isWasmInitialized) {
29369 throw new Error("initializeWasm() must be awaited first!");
29371 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
29372 return nativeResponseValue;
29374 // void Ping_free(struct LDKPing this_obj);
29376 export function Ping_free(this_obj: bigint): void {
29377 if(!isWasmInitialized) {
29378 throw new Error("initializeWasm() must be awaited first!");
29380 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
29381 // debug statements here
29383 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
29385 export function Ping_get_ponglen(this_ptr: bigint): number {
29386 if(!isWasmInitialized) {
29387 throw new Error("initializeWasm() must be awaited first!");
29389 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
29390 return nativeResponseValue;
29392 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
29394 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
29395 if(!isWasmInitialized) {
29396 throw new Error("initializeWasm() must be awaited first!");
29398 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
29399 // debug statements here
29401 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
29403 export function Ping_get_byteslen(this_ptr: bigint): number {
29404 if(!isWasmInitialized) {
29405 throw new Error("initializeWasm() must be awaited first!");
29407 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
29408 return nativeResponseValue;
29410 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
29412 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
29413 if(!isWasmInitialized) {
29414 throw new Error("initializeWasm() must be awaited first!");
29416 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
29417 // debug statements here
29419 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
29421 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
29422 if(!isWasmInitialized) {
29423 throw new Error("initializeWasm() must be awaited first!");
29425 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
29426 return nativeResponseValue;
29428 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
29430 export function Ping_clone_ptr(arg: bigint): bigint {
29431 if(!isWasmInitialized) {
29432 throw new Error("initializeWasm() must be awaited first!");
29434 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
29435 return nativeResponseValue;
29437 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
29439 export function Ping_clone(orig: bigint): bigint {
29440 if(!isWasmInitialized) {
29441 throw new Error("initializeWasm() must be awaited first!");
29443 const nativeResponseValue = wasm.TS_Ping_clone(orig);
29444 return nativeResponseValue;
29446 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
29448 export function Ping_eq(a: bigint, b: bigint): boolean {
29449 if(!isWasmInitialized) {
29450 throw new Error("initializeWasm() must be awaited first!");
29452 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
29453 return nativeResponseValue;
29455 // void Pong_free(struct LDKPong this_obj);
29457 export function Pong_free(this_obj: bigint): void {
29458 if(!isWasmInitialized) {
29459 throw new Error("initializeWasm() must be awaited first!");
29461 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
29462 // debug statements here
29464 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
29466 export function Pong_get_byteslen(this_ptr: bigint): number {
29467 if(!isWasmInitialized) {
29468 throw new Error("initializeWasm() must be awaited first!");
29470 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
29471 return nativeResponseValue;
29473 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
29475 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
29476 if(!isWasmInitialized) {
29477 throw new Error("initializeWasm() must be awaited first!");
29479 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
29480 // debug statements here
29482 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
29484 export function Pong_new(byteslen_arg: number): bigint {
29485 if(!isWasmInitialized) {
29486 throw new Error("initializeWasm() must be awaited first!");
29488 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
29489 return nativeResponseValue;
29491 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
29493 export function Pong_clone_ptr(arg: bigint): bigint {
29494 if(!isWasmInitialized) {
29495 throw new Error("initializeWasm() must be awaited first!");
29497 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
29498 return nativeResponseValue;
29500 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
29502 export function Pong_clone(orig: bigint): bigint {
29503 if(!isWasmInitialized) {
29504 throw new Error("initializeWasm() must be awaited first!");
29506 const nativeResponseValue = wasm.TS_Pong_clone(orig);
29507 return nativeResponseValue;
29509 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
29511 export function Pong_eq(a: bigint, b: bigint): boolean {
29512 if(!isWasmInitialized) {
29513 throw new Error("initializeWasm() must be awaited first!");
29515 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
29516 return nativeResponseValue;
29518 // void OpenChannel_free(struct LDKOpenChannel this_obj);
29520 export function OpenChannel_free(this_obj: bigint): void {
29521 if(!isWasmInitialized) {
29522 throw new Error("initializeWasm() must be awaited first!");
29524 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
29525 // debug statements here
29527 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
29529 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
29530 if(!isWasmInitialized) {
29531 throw new Error("initializeWasm() must be awaited first!");
29533 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
29534 return nativeResponseValue;
29536 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29538 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
29539 if(!isWasmInitialized) {
29540 throw new Error("initializeWasm() must be awaited first!");
29542 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
29543 // debug statements here
29545 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
29547 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
29548 if(!isWasmInitialized) {
29549 throw new Error("initializeWasm() must be awaited first!");
29551 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
29552 return nativeResponseValue;
29554 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29556 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
29557 if(!isWasmInitialized) {
29558 throw new Error("initializeWasm() must be awaited first!");
29560 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
29561 // debug statements here
29563 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29565 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
29566 if(!isWasmInitialized) {
29567 throw new Error("initializeWasm() must be awaited first!");
29569 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
29570 return nativeResponseValue;
29572 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
29574 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
29575 if(!isWasmInitialized) {
29576 throw new Error("initializeWasm() must be awaited first!");
29578 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
29579 // debug statements here
29581 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29583 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
29584 if(!isWasmInitialized) {
29585 throw new Error("initializeWasm() must be awaited first!");
29587 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
29588 return nativeResponseValue;
29590 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
29592 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
29593 if(!isWasmInitialized) {
29594 throw new Error("initializeWasm() must be awaited first!");
29596 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
29597 // debug statements here
29599 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29601 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
29602 if(!isWasmInitialized) {
29603 throw new Error("initializeWasm() must be awaited first!");
29605 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
29606 return nativeResponseValue;
29608 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
29610 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
29611 if(!isWasmInitialized) {
29612 throw new Error("initializeWasm() must be awaited first!");
29614 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
29615 // debug statements here
29617 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29619 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
29620 if(!isWasmInitialized) {
29621 throw new Error("initializeWasm() must be awaited first!");
29623 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
29624 return nativeResponseValue;
29626 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
29628 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
29629 if(!isWasmInitialized) {
29630 throw new Error("initializeWasm() must be awaited first!");
29632 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
29633 // debug statements here
29635 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29637 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
29638 if(!isWasmInitialized) {
29639 throw new Error("initializeWasm() must be awaited first!");
29641 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
29642 return nativeResponseValue;
29644 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
29646 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
29647 if(!isWasmInitialized) {
29648 throw new Error("initializeWasm() must be awaited first!");
29650 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
29651 // debug statements here
29653 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29655 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
29656 if(!isWasmInitialized) {
29657 throw new Error("initializeWasm() must be awaited first!");
29659 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
29660 return nativeResponseValue;
29662 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
29664 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
29665 if(!isWasmInitialized) {
29666 throw new Error("initializeWasm() must be awaited first!");
29668 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
29669 // debug statements here
29671 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29673 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
29674 if(!isWasmInitialized) {
29675 throw new Error("initializeWasm() must be awaited first!");
29677 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
29678 return nativeResponseValue;
29680 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
29682 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
29683 if(!isWasmInitialized) {
29684 throw new Error("initializeWasm() must be awaited first!");
29686 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
29687 // debug statements here
29689 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29691 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
29692 if(!isWasmInitialized) {
29693 throw new Error("initializeWasm() must be awaited first!");
29695 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
29696 return nativeResponseValue;
29698 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
29700 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
29701 if(!isWasmInitialized) {
29702 throw new Error("initializeWasm() must be awaited first!");
29704 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
29705 // debug statements here
29707 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29709 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
29710 if(!isWasmInitialized) {
29711 throw new Error("initializeWasm() must be awaited first!");
29713 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
29714 return nativeResponseValue;
29716 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
29718 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
29719 if(!isWasmInitialized) {
29720 throw new Error("initializeWasm() must be awaited first!");
29722 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
29723 // debug statements here
29725 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29727 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
29728 if(!isWasmInitialized) {
29729 throw new Error("initializeWasm() must be awaited first!");
29731 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
29732 return nativeResponseValue;
29734 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29736 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
29737 if(!isWasmInitialized) {
29738 throw new Error("initializeWasm() must be awaited first!");
29740 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
29741 // debug statements here
29743 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29745 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
29746 if(!isWasmInitialized) {
29747 throw new Error("initializeWasm() must be awaited first!");
29749 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
29750 return nativeResponseValue;
29752 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29754 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
29755 if(!isWasmInitialized) {
29756 throw new Error("initializeWasm() must be awaited first!");
29758 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
29759 // debug statements here
29761 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29763 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
29764 if(!isWasmInitialized) {
29765 throw new Error("initializeWasm() must be awaited first!");
29767 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
29768 return nativeResponseValue;
29770 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29772 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
29773 if(!isWasmInitialized) {
29774 throw new Error("initializeWasm() must be awaited first!");
29776 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
29777 // debug statements here
29779 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29781 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
29782 if(!isWasmInitialized) {
29783 throw new Error("initializeWasm() must be awaited first!");
29785 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
29786 return nativeResponseValue;
29788 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29790 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
29791 if(!isWasmInitialized) {
29792 throw new Error("initializeWasm() must be awaited first!");
29794 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
29795 // debug statements here
29797 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29799 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
29800 if(!isWasmInitialized) {
29801 throw new Error("initializeWasm() must be awaited first!");
29803 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
29804 return nativeResponseValue;
29806 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29808 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
29809 if(!isWasmInitialized) {
29810 throw new Error("initializeWasm() must be awaited first!");
29812 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
29813 // debug statements here
29815 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29817 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
29818 if(!isWasmInitialized) {
29819 throw new Error("initializeWasm() must be awaited first!");
29821 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
29822 return nativeResponseValue;
29824 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29826 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
29827 if(!isWasmInitialized) {
29828 throw new Error("initializeWasm() must be awaited first!");
29830 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
29831 // debug statements here
29833 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29835 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
29836 if(!isWasmInitialized) {
29837 throw new Error("initializeWasm() must be awaited first!");
29839 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
29840 return nativeResponseValue;
29842 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
29844 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
29845 if(!isWasmInitialized) {
29846 throw new Error("initializeWasm() must be awaited first!");
29848 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
29849 // debug statements here
29851 // struct LDKCOption_CVec_u8ZZ OpenChannel_get_shutdown_scriptpubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29853 export function OpenChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
29854 if(!isWasmInitialized) {
29855 throw new Error("initializeWasm() must be awaited first!");
29857 const nativeResponseValue = wasm.TS_OpenChannel_get_shutdown_scriptpubkey(this_ptr);
29858 return nativeResponseValue;
29860 // void OpenChannel_set_shutdown_scriptpubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
29862 export function OpenChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
29863 if(!isWasmInitialized) {
29864 throw new Error("initializeWasm() must be awaited first!");
29866 const nativeResponseValue = wasm.TS_OpenChannel_set_shutdown_scriptpubkey(this_ptr, val);
29867 // debug statements here
29869 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
29871 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
29872 if(!isWasmInitialized) {
29873 throw new Error("initializeWasm() must be awaited first!");
29875 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
29876 return nativeResponseValue;
29878 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
29880 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
29881 if(!isWasmInitialized) {
29882 throw new Error("initializeWasm() must be awaited first!");
29884 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
29885 // debug statements here
29887 // 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_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg);
29889 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 {
29890 if(!isWasmInitialized) {
29891 throw new Error("initializeWasm() must be awaited first!");
29893 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);
29894 return nativeResponseValue;
29896 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
29898 export function OpenChannel_clone_ptr(arg: bigint): bigint {
29899 if(!isWasmInitialized) {
29900 throw new Error("initializeWasm() must be awaited first!");
29902 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
29903 return nativeResponseValue;
29905 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
29907 export function OpenChannel_clone(orig: bigint): bigint {
29908 if(!isWasmInitialized) {
29909 throw new Error("initializeWasm() must be awaited first!");
29911 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
29912 return nativeResponseValue;
29914 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
29916 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
29917 if(!isWasmInitialized) {
29918 throw new Error("initializeWasm() must be awaited first!");
29920 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
29921 return nativeResponseValue;
29923 // void OpenChannelV2_free(struct LDKOpenChannelV2 this_obj);
29925 export function OpenChannelV2_free(this_obj: bigint): void {
29926 if(!isWasmInitialized) {
29927 throw new Error("initializeWasm() must be awaited first!");
29929 const nativeResponseValue = wasm.TS_OpenChannelV2_free(this_obj);
29930 // debug statements here
29932 // const uint8_t (*OpenChannelV2_get_chain_hash(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
29934 export function OpenChannelV2_get_chain_hash(this_ptr: bigint): number {
29935 if(!isWasmInitialized) {
29936 throw new Error("initializeWasm() must be awaited first!");
29938 const nativeResponseValue = wasm.TS_OpenChannelV2_get_chain_hash(this_ptr);
29939 return nativeResponseValue;
29941 // void OpenChannelV2_set_chain_hash(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29943 export function OpenChannelV2_set_chain_hash(this_ptr: bigint, val: number): void {
29944 if(!isWasmInitialized) {
29945 throw new Error("initializeWasm() must be awaited first!");
29947 const nativeResponseValue = wasm.TS_OpenChannelV2_set_chain_hash(this_ptr, val);
29948 // debug statements here
29950 // const uint8_t (*OpenChannelV2_get_temporary_channel_id(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
29952 export function OpenChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
29953 if(!isWasmInitialized) {
29954 throw new Error("initializeWasm() must be awaited first!");
29956 const nativeResponseValue = wasm.TS_OpenChannelV2_get_temporary_channel_id(this_ptr);
29957 return nativeResponseValue;
29959 // void OpenChannelV2_set_temporary_channel_id(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29961 export function OpenChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
29962 if(!isWasmInitialized) {
29963 throw new Error("initializeWasm() must be awaited first!");
29965 const nativeResponseValue = wasm.TS_OpenChannelV2_set_temporary_channel_id(this_ptr, val);
29966 // debug statements here
29968 // uint32_t OpenChannelV2_get_funding_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
29970 export function OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr: bigint): number {
29971 if(!isWasmInitialized) {
29972 throw new Error("initializeWasm() must be awaited first!");
29974 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr);
29975 return nativeResponseValue;
29977 // void OpenChannelV2_set_funding_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
29979 export function OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
29980 if(!isWasmInitialized) {
29981 throw new Error("initializeWasm() must be awaited first!");
29983 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr, val);
29984 // debug statements here
29986 // uint32_t OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
29988 export function OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr: bigint): number {
29989 if(!isWasmInitialized) {
29990 throw new Error("initializeWasm() must be awaited first!");
29992 const nativeResponseValue = wasm.TS_OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr);
29993 return nativeResponseValue;
29995 // void OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
29997 export function OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
29998 if(!isWasmInitialized) {
29999 throw new Error("initializeWasm() must be awaited first!");
30001 const nativeResponseValue = wasm.TS_OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr, val);
30002 // debug statements here
30004 // uint64_t OpenChannelV2_get_funding_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30006 export function OpenChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
30007 if(!isWasmInitialized) {
30008 throw new Error("initializeWasm() must be awaited first!");
30010 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_satoshis(this_ptr);
30011 return nativeResponseValue;
30013 // void OpenChannelV2_set_funding_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30015 export function OpenChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
30016 if(!isWasmInitialized) {
30017 throw new Error("initializeWasm() must be awaited first!");
30019 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_satoshis(this_ptr, val);
30020 // debug statements here
30022 // uint64_t OpenChannelV2_get_dust_limit_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30024 export function OpenChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
30025 if(!isWasmInitialized) {
30026 throw new Error("initializeWasm() must be awaited first!");
30028 const nativeResponseValue = wasm.TS_OpenChannelV2_get_dust_limit_satoshis(this_ptr);
30029 return nativeResponseValue;
30031 // void OpenChannelV2_set_dust_limit_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30033 export function OpenChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
30034 if(!isWasmInitialized) {
30035 throw new Error("initializeWasm() must be awaited first!");
30037 const nativeResponseValue = wasm.TS_OpenChannelV2_set_dust_limit_satoshis(this_ptr, val);
30038 // debug statements here
30040 // uint64_t OpenChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30042 export function OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30043 if(!isWasmInitialized) {
30044 throw new Error("initializeWasm() must be awaited first!");
30046 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
30047 return nativeResponseValue;
30049 // void OpenChannelV2_set_max_htlc_value_in_flight_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30051 export function OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30052 if(!isWasmInitialized) {
30053 throw new Error("initializeWasm() must be awaited first!");
30055 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
30056 // debug statements here
30058 // uint64_t OpenChannelV2_get_htlc_minimum_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30060 export function OpenChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30061 if(!isWasmInitialized) {
30062 throw new Error("initializeWasm() must be awaited first!");
30064 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_minimum_msat(this_ptr);
30065 return nativeResponseValue;
30067 // void OpenChannelV2_set_htlc_minimum_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30069 export function OpenChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30070 if(!isWasmInitialized) {
30071 throw new Error("initializeWasm() must be awaited first!");
30073 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_minimum_msat(this_ptr, val);
30074 // debug statements here
30076 // uint16_t OpenChannelV2_get_to_self_delay(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30078 export function OpenChannelV2_get_to_self_delay(this_ptr: bigint): number {
30079 if(!isWasmInitialized) {
30080 throw new Error("initializeWasm() must be awaited first!");
30082 const nativeResponseValue = wasm.TS_OpenChannelV2_get_to_self_delay(this_ptr);
30083 return nativeResponseValue;
30085 // void OpenChannelV2_set_to_self_delay(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
30087 export function OpenChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
30088 if(!isWasmInitialized) {
30089 throw new Error("initializeWasm() must be awaited first!");
30091 const nativeResponseValue = wasm.TS_OpenChannelV2_set_to_self_delay(this_ptr, val);
30092 // debug statements here
30094 // uint16_t OpenChannelV2_get_max_accepted_htlcs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30096 export function OpenChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
30097 if(!isWasmInitialized) {
30098 throw new Error("initializeWasm() must be awaited first!");
30100 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_accepted_htlcs(this_ptr);
30101 return nativeResponseValue;
30103 // void OpenChannelV2_set_max_accepted_htlcs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
30105 export function OpenChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30106 if(!isWasmInitialized) {
30107 throw new Error("initializeWasm() must be awaited first!");
30109 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_accepted_htlcs(this_ptr, val);
30110 // debug statements here
30112 // uint32_t OpenChannelV2_get_locktime(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30114 export function OpenChannelV2_get_locktime(this_ptr: bigint): number {
30115 if(!isWasmInitialized) {
30116 throw new Error("initializeWasm() must be awaited first!");
30118 const nativeResponseValue = wasm.TS_OpenChannelV2_get_locktime(this_ptr);
30119 return nativeResponseValue;
30121 // void OpenChannelV2_set_locktime(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
30123 export function OpenChannelV2_set_locktime(this_ptr: bigint, val: number): void {
30124 if(!isWasmInitialized) {
30125 throw new Error("initializeWasm() must be awaited first!");
30127 const nativeResponseValue = wasm.TS_OpenChannelV2_set_locktime(this_ptr, val);
30128 // debug statements here
30130 // struct LDKPublicKey OpenChannelV2_get_funding_pubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30132 export function OpenChannelV2_get_funding_pubkey(this_ptr: bigint): number {
30133 if(!isWasmInitialized) {
30134 throw new Error("initializeWasm() must be awaited first!");
30136 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_pubkey(this_ptr);
30137 return nativeResponseValue;
30139 // void OpenChannelV2_set_funding_pubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30141 export function OpenChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
30142 if(!isWasmInitialized) {
30143 throw new Error("initializeWasm() must be awaited first!");
30145 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_pubkey(this_ptr, val);
30146 // debug statements here
30148 // struct LDKPublicKey OpenChannelV2_get_revocation_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30150 export function OpenChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
30151 if(!isWasmInitialized) {
30152 throw new Error("initializeWasm() must be awaited first!");
30154 const nativeResponseValue = wasm.TS_OpenChannelV2_get_revocation_basepoint(this_ptr);
30155 return nativeResponseValue;
30157 // void OpenChannelV2_set_revocation_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30159 export function OpenChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
30160 if(!isWasmInitialized) {
30161 throw new Error("initializeWasm() must be awaited first!");
30163 const nativeResponseValue = wasm.TS_OpenChannelV2_set_revocation_basepoint(this_ptr, val);
30164 // debug statements here
30166 // struct LDKPublicKey OpenChannelV2_get_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30168 export function OpenChannelV2_get_payment_basepoint(this_ptr: bigint): number {
30169 if(!isWasmInitialized) {
30170 throw new Error("initializeWasm() must be awaited first!");
30172 const nativeResponseValue = wasm.TS_OpenChannelV2_get_payment_basepoint(this_ptr);
30173 return nativeResponseValue;
30175 // void OpenChannelV2_set_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30177 export function OpenChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
30178 if(!isWasmInitialized) {
30179 throw new Error("initializeWasm() must be awaited first!");
30181 const nativeResponseValue = wasm.TS_OpenChannelV2_set_payment_basepoint(this_ptr, val);
30182 // debug statements here
30184 // struct LDKPublicKey OpenChannelV2_get_delayed_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30186 export function OpenChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
30187 if(!isWasmInitialized) {
30188 throw new Error("initializeWasm() must be awaited first!");
30190 const nativeResponseValue = wasm.TS_OpenChannelV2_get_delayed_payment_basepoint(this_ptr);
30191 return nativeResponseValue;
30193 // void OpenChannelV2_set_delayed_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30195 export function OpenChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
30196 if(!isWasmInitialized) {
30197 throw new Error("initializeWasm() must be awaited first!");
30199 const nativeResponseValue = wasm.TS_OpenChannelV2_set_delayed_payment_basepoint(this_ptr, val);
30200 // debug statements here
30202 // struct LDKPublicKey OpenChannelV2_get_htlc_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30204 export function OpenChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
30205 if(!isWasmInitialized) {
30206 throw new Error("initializeWasm() must be awaited first!");
30208 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_basepoint(this_ptr);
30209 return nativeResponseValue;
30211 // void OpenChannelV2_set_htlc_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30213 export function OpenChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
30214 if(!isWasmInitialized) {
30215 throw new Error("initializeWasm() must be awaited first!");
30217 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_basepoint(this_ptr, val);
30218 // debug statements here
30220 // struct LDKPublicKey OpenChannelV2_get_first_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30222 export function OpenChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
30223 if(!isWasmInitialized) {
30224 throw new Error("initializeWasm() must be awaited first!");
30226 const nativeResponseValue = wasm.TS_OpenChannelV2_get_first_per_commitment_point(this_ptr);
30227 return nativeResponseValue;
30229 // void OpenChannelV2_set_first_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30231 export function OpenChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
30232 if(!isWasmInitialized) {
30233 throw new Error("initializeWasm() must be awaited first!");
30235 const nativeResponseValue = wasm.TS_OpenChannelV2_set_first_per_commitment_point(this_ptr, val);
30236 // debug statements here
30238 // struct LDKPublicKey OpenChannelV2_get_second_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30240 export function OpenChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
30241 if(!isWasmInitialized) {
30242 throw new Error("initializeWasm() must be awaited first!");
30244 const nativeResponseValue = wasm.TS_OpenChannelV2_get_second_per_commitment_point(this_ptr);
30245 return nativeResponseValue;
30247 // void OpenChannelV2_set_second_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30249 export function OpenChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
30250 if(!isWasmInitialized) {
30251 throw new Error("initializeWasm() must be awaited first!");
30253 const nativeResponseValue = wasm.TS_OpenChannelV2_set_second_per_commitment_point(this_ptr, val);
30254 // debug statements here
30256 // uint8_t OpenChannelV2_get_channel_flags(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30258 export function OpenChannelV2_get_channel_flags(this_ptr: bigint): number {
30259 if(!isWasmInitialized) {
30260 throw new Error("initializeWasm() must be awaited first!");
30262 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_flags(this_ptr);
30263 return nativeResponseValue;
30265 // void OpenChannelV2_set_channel_flags(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint8_t val);
30267 export function OpenChannelV2_set_channel_flags(this_ptr: bigint, val: number): void {
30268 if(!isWasmInitialized) {
30269 throw new Error("initializeWasm() must be awaited first!");
30271 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_flags(this_ptr, val);
30272 // debug statements here
30274 // struct LDKCOption_CVec_u8ZZ OpenChannelV2_get_shutdown_scriptpubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30276 export function OpenChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
30277 if(!isWasmInitialized) {
30278 throw new Error("initializeWasm() must be awaited first!");
30280 const nativeResponseValue = wasm.TS_OpenChannelV2_get_shutdown_scriptpubkey(this_ptr);
30281 return nativeResponseValue;
30283 // void OpenChannelV2_set_shutdown_scriptpubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
30285 export function OpenChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
30286 if(!isWasmInitialized) {
30287 throw new Error("initializeWasm() must be awaited first!");
30289 const nativeResponseValue = wasm.TS_OpenChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
30290 // debug statements here
30292 // struct LDKChannelTypeFeatures OpenChannelV2_get_channel_type(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30294 export function OpenChannelV2_get_channel_type(this_ptr: bigint): bigint {
30295 if(!isWasmInitialized) {
30296 throw new Error("initializeWasm() must be awaited first!");
30298 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_type(this_ptr);
30299 return nativeResponseValue;
30301 // void OpenChannelV2_set_channel_type(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
30303 export function OpenChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
30304 if(!isWasmInitialized) {
30305 throw new Error("initializeWasm() must be awaited first!");
30307 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_type(this_ptr, val);
30308 // debug statements here
30310 // enum LDKCOption_NoneZ OpenChannelV2_get_require_confirmed_inputs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30312 export function OpenChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
30313 if(!isWasmInitialized) {
30314 throw new Error("initializeWasm() must be awaited first!");
30316 const nativeResponseValue = wasm.TS_OpenChannelV2_get_require_confirmed_inputs(this_ptr);
30317 return nativeResponseValue;
30319 // void OpenChannelV2_set_require_confirmed_inputs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
30321 export function OpenChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
30322 if(!isWasmInitialized) {
30323 throw new Error("initializeWasm() must be awaited first!");
30325 const nativeResponseValue = wasm.TS_OpenChannelV2_set_require_confirmed_inputs(this_ptr, val);
30326 // debug statements here
30328 // 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_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
30330 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 {
30331 if(!isWasmInitialized) {
30332 throw new Error("initializeWasm() must be awaited first!");
30334 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);
30335 return nativeResponseValue;
30337 // uint64_t OpenChannelV2_clone_ptr(LDKOpenChannelV2 *NONNULL_PTR arg);
30339 export function OpenChannelV2_clone_ptr(arg: bigint): bigint {
30340 if(!isWasmInitialized) {
30341 throw new Error("initializeWasm() must be awaited first!");
30343 const nativeResponseValue = wasm.TS_OpenChannelV2_clone_ptr(arg);
30344 return nativeResponseValue;
30346 // struct LDKOpenChannelV2 OpenChannelV2_clone(const struct LDKOpenChannelV2 *NONNULL_PTR orig);
30348 export function OpenChannelV2_clone(orig: bigint): bigint {
30349 if(!isWasmInitialized) {
30350 throw new Error("initializeWasm() must be awaited first!");
30352 const nativeResponseValue = wasm.TS_OpenChannelV2_clone(orig);
30353 return nativeResponseValue;
30355 // bool OpenChannelV2_eq(const struct LDKOpenChannelV2 *NONNULL_PTR a, const struct LDKOpenChannelV2 *NONNULL_PTR b);
30357 export function OpenChannelV2_eq(a: bigint, b: bigint): boolean {
30358 if(!isWasmInitialized) {
30359 throw new Error("initializeWasm() must be awaited first!");
30361 const nativeResponseValue = wasm.TS_OpenChannelV2_eq(a, b);
30362 return nativeResponseValue;
30364 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
30366 export function AcceptChannel_free(this_obj: bigint): void {
30367 if(!isWasmInitialized) {
30368 throw new Error("initializeWasm() must be awaited first!");
30370 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
30371 // debug statements here
30373 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
30375 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
30376 if(!isWasmInitialized) {
30377 throw new Error("initializeWasm() must be awaited first!");
30379 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
30380 return nativeResponseValue;
30382 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30384 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
30385 if(!isWasmInitialized) {
30386 throw new Error("initializeWasm() must be awaited first!");
30388 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
30389 // debug statements here
30391 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30393 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
30394 if(!isWasmInitialized) {
30395 throw new Error("initializeWasm() must be awaited first!");
30397 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
30398 return nativeResponseValue;
30400 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30402 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
30403 if(!isWasmInitialized) {
30404 throw new Error("initializeWasm() must be awaited first!");
30406 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
30407 // debug statements here
30409 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30411 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30412 if(!isWasmInitialized) {
30413 throw new Error("initializeWasm() must be awaited first!");
30415 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
30416 return nativeResponseValue;
30418 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30420 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30421 if(!isWasmInitialized) {
30422 throw new Error("initializeWasm() must be awaited first!");
30424 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
30425 // debug statements here
30427 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30429 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
30430 if(!isWasmInitialized) {
30431 throw new Error("initializeWasm() must be awaited first!");
30433 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
30434 return nativeResponseValue;
30436 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30438 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
30439 if(!isWasmInitialized) {
30440 throw new Error("initializeWasm() must be awaited first!");
30442 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
30443 // debug statements here
30445 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30447 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30448 if(!isWasmInitialized) {
30449 throw new Error("initializeWasm() must be awaited first!");
30451 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
30452 return nativeResponseValue;
30454 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30456 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30457 if(!isWasmInitialized) {
30458 throw new Error("initializeWasm() must be awaited first!");
30460 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
30461 // debug statements here
30463 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30465 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
30466 if(!isWasmInitialized) {
30467 throw new Error("initializeWasm() must be awaited first!");
30469 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
30470 return nativeResponseValue;
30472 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
30474 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
30475 if(!isWasmInitialized) {
30476 throw new Error("initializeWasm() must be awaited first!");
30478 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
30479 // debug statements here
30481 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30483 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
30484 if(!isWasmInitialized) {
30485 throw new Error("initializeWasm() must be awaited first!");
30487 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
30488 return nativeResponseValue;
30490 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
30492 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
30493 if(!isWasmInitialized) {
30494 throw new Error("initializeWasm() must be awaited first!");
30496 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
30497 // debug statements here
30499 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30501 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
30502 if(!isWasmInitialized) {
30503 throw new Error("initializeWasm() must be awaited first!");
30505 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
30506 return nativeResponseValue;
30508 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
30510 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30511 if(!isWasmInitialized) {
30512 throw new Error("initializeWasm() must be awaited first!");
30514 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
30515 // debug statements here
30517 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30519 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
30520 if(!isWasmInitialized) {
30521 throw new Error("initializeWasm() must be awaited first!");
30523 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
30524 return nativeResponseValue;
30526 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30528 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
30529 if(!isWasmInitialized) {
30530 throw new Error("initializeWasm() must be awaited first!");
30532 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
30533 // debug statements here
30535 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30537 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
30538 if(!isWasmInitialized) {
30539 throw new Error("initializeWasm() must be awaited first!");
30541 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
30542 return nativeResponseValue;
30544 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30546 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
30547 if(!isWasmInitialized) {
30548 throw new Error("initializeWasm() must be awaited first!");
30550 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
30551 // debug statements here
30553 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30555 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
30556 if(!isWasmInitialized) {
30557 throw new Error("initializeWasm() must be awaited first!");
30559 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
30560 return nativeResponseValue;
30562 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30564 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
30565 if(!isWasmInitialized) {
30566 throw new Error("initializeWasm() must be awaited first!");
30568 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
30569 // debug statements here
30571 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30573 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
30574 if(!isWasmInitialized) {
30575 throw new Error("initializeWasm() must be awaited first!");
30577 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
30578 return nativeResponseValue;
30580 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30582 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
30583 if(!isWasmInitialized) {
30584 throw new Error("initializeWasm() must be awaited first!");
30586 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
30587 // debug statements here
30589 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30591 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
30592 if(!isWasmInitialized) {
30593 throw new Error("initializeWasm() must be awaited first!");
30595 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
30596 return nativeResponseValue;
30598 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30600 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
30601 if(!isWasmInitialized) {
30602 throw new Error("initializeWasm() must be awaited first!");
30604 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
30605 // debug statements here
30607 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30609 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
30610 if(!isWasmInitialized) {
30611 throw new Error("initializeWasm() must be awaited first!");
30613 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
30614 return nativeResponseValue;
30616 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30618 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
30619 if(!isWasmInitialized) {
30620 throw new Error("initializeWasm() must be awaited first!");
30622 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
30623 // debug statements here
30625 // struct LDKCOption_CVec_u8ZZ AcceptChannel_get_shutdown_scriptpubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30627 export function AcceptChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
30628 if(!isWasmInitialized) {
30629 throw new Error("initializeWasm() must be awaited first!");
30631 const nativeResponseValue = wasm.TS_AcceptChannel_get_shutdown_scriptpubkey(this_ptr);
30632 return nativeResponseValue;
30634 // void AcceptChannel_set_shutdown_scriptpubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
30636 export function AcceptChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
30637 if(!isWasmInitialized) {
30638 throw new Error("initializeWasm() must be awaited first!");
30640 const nativeResponseValue = wasm.TS_AcceptChannel_set_shutdown_scriptpubkey(this_ptr, val);
30641 // debug statements here
30643 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30645 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
30646 if(!isWasmInitialized) {
30647 throw new Error("initializeWasm() must be awaited first!");
30649 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
30650 return nativeResponseValue;
30652 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
30654 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
30655 if(!isWasmInitialized) {
30656 throw new Error("initializeWasm() must be awaited first!");
30658 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
30659 // debug statements here
30661 // 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_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg);
30663 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 {
30664 if(!isWasmInitialized) {
30665 throw new Error("initializeWasm() must be awaited first!");
30667 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);
30668 return nativeResponseValue;
30670 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
30672 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
30673 if(!isWasmInitialized) {
30674 throw new Error("initializeWasm() must be awaited first!");
30676 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
30677 return nativeResponseValue;
30679 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
30681 export function AcceptChannel_clone(orig: bigint): bigint {
30682 if(!isWasmInitialized) {
30683 throw new Error("initializeWasm() must be awaited first!");
30685 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
30686 return nativeResponseValue;
30688 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
30690 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
30691 if(!isWasmInitialized) {
30692 throw new Error("initializeWasm() must be awaited first!");
30694 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
30695 return nativeResponseValue;
30697 // void AcceptChannelV2_free(struct LDKAcceptChannelV2 this_obj);
30699 export function AcceptChannelV2_free(this_obj: bigint): void {
30700 if(!isWasmInitialized) {
30701 throw new Error("initializeWasm() must be awaited first!");
30703 const nativeResponseValue = wasm.TS_AcceptChannelV2_free(this_obj);
30704 // debug statements here
30706 // const uint8_t (*AcceptChannelV2_get_temporary_channel_id(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr))[32];
30708 export function AcceptChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
30709 if(!isWasmInitialized) {
30710 throw new Error("initializeWasm() must be awaited first!");
30712 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_temporary_channel_id(this_ptr);
30713 return nativeResponseValue;
30715 // void AcceptChannelV2_set_temporary_channel_id(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30717 export function AcceptChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
30718 if(!isWasmInitialized) {
30719 throw new Error("initializeWasm() must be awaited first!");
30721 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_temporary_channel_id(this_ptr, val);
30722 // debug statements here
30724 // uint64_t AcceptChannelV2_get_funding_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30726 export function AcceptChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
30727 if(!isWasmInitialized) {
30728 throw new Error("initializeWasm() must be awaited first!");
30730 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_satoshis(this_ptr);
30731 return nativeResponseValue;
30733 // void AcceptChannelV2_set_funding_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30735 export function AcceptChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
30736 if(!isWasmInitialized) {
30737 throw new Error("initializeWasm() must be awaited first!");
30739 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_satoshis(this_ptr, val);
30740 // debug statements here
30742 // uint64_t AcceptChannelV2_get_dust_limit_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30744 export function AcceptChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
30745 if(!isWasmInitialized) {
30746 throw new Error("initializeWasm() must be awaited first!");
30748 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_dust_limit_satoshis(this_ptr);
30749 return nativeResponseValue;
30751 // void AcceptChannelV2_set_dust_limit_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30753 export function AcceptChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
30754 if(!isWasmInitialized) {
30755 throw new Error("initializeWasm() must be awaited first!");
30757 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_dust_limit_satoshis(this_ptr, val);
30758 // debug statements here
30760 // uint64_t AcceptChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30762 export function AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30763 if(!isWasmInitialized) {
30764 throw new Error("initializeWasm() must be awaited first!");
30766 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
30767 return nativeResponseValue;
30769 // void AcceptChannelV2_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30771 export function AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30772 if(!isWasmInitialized) {
30773 throw new Error("initializeWasm() must be awaited first!");
30775 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
30776 // debug statements here
30778 // uint64_t AcceptChannelV2_get_htlc_minimum_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30780 export function AcceptChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30781 if(!isWasmInitialized) {
30782 throw new Error("initializeWasm() must be awaited first!");
30784 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_minimum_msat(this_ptr);
30785 return nativeResponseValue;
30787 // void AcceptChannelV2_set_htlc_minimum_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30789 export function AcceptChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30790 if(!isWasmInitialized) {
30791 throw new Error("initializeWasm() must be awaited first!");
30793 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_minimum_msat(this_ptr, val);
30794 // debug statements here
30796 // uint32_t AcceptChannelV2_get_minimum_depth(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30798 export function AcceptChannelV2_get_minimum_depth(this_ptr: bigint): number {
30799 if(!isWasmInitialized) {
30800 throw new Error("initializeWasm() must be awaited first!");
30802 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_minimum_depth(this_ptr);
30803 return nativeResponseValue;
30805 // void AcceptChannelV2_set_minimum_depth(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
30807 export function AcceptChannelV2_set_minimum_depth(this_ptr: bigint, val: number): void {
30808 if(!isWasmInitialized) {
30809 throw new Error("initializeWasm() must be awaited first!");
30811 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_minimum_depth(this_ptr, val);
30812 // debug statements here
30814 // uint16_t AcceptChannelV2_get_to_self_delay(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30816 export function AcceptChannelV2_get_to_self_delay(this_ptr: bigint): number {
30817 if(!isWasmInitialized) {
30818 throw new Error("initializeWasm() must be awaited first!");
30820 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_to_self_delay(this_ptr);
30821 return nativeResponseValue;
30823 // void AcceptChannelV2_set_to_self_delay(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
30825 export function AcceptChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
30826 if(!isWasmInitialized) {
30827 throw new Error("initializeWasm() must be awaited first!");
30829 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_to_self_delay(this_ptr, val);
30830 // debug statements here
30832 // uint16_t AcceptChannelV2_get_max_accepted_htlcs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30834 export function AcceptChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
30835 if(!isWasmInitialized) {
30836 throw new Error("initializeWasm() must be awaited first!");
30838 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_accepted_htlcs(this_ptr);
30839 return nativeResponseValue;
30841 // void AcceptChannelV2_set_max_accepted_htlcs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
30843 export function AcceptChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30844 if(!isWasmInitialized) {
30845 throw new Error("initializeWasm() must be awaited first!");
30847 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_accepted_htlcs(this_ptr, val);
30848 // debug statements here
30850 // struct LDKPublicKey AcceptChannelV2_get_funding_pubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30852 export function AcceptChannelV2_get_funding_pubkey(this_ptr: bigint): number {
30853 if(!isWasmInitialized) {
30854 throw new Error("initializeWasm() must be awaited first!");
30856 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_pubkey(this_ptr);
30857 return nativeResponseValue;
30859 // void AcceptChannelV2_set_funding_pubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30861 export function AcceptChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
30862 if(!isWasmInitialized) {
30863 throw new Error("initializeWasm() must be awaited first!");
30865 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_pubkey(this_ptr, val);
30866 // debug statements here
30868 // struct LDKPublicKey AcceptChannelV2_get_revocation_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30870 export function AcceptChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
30871 if(!isWasmInitialized) {
30872 throw new Error("initializeWasm() must be awaited first!");
30874 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_revocation_basepoint(this_ptr);
30875 return nativeResponseValue;
30877 // void AcceptChannelV2_set_revocation_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30879 export function AcceptChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
30880 if(!isWasmInitialized) {
30881 throw new Error("initializeWasm() must be awaited first!");
30883 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_revocation_basepoint(this_ptr, val);
30884 // debug statements here
30886 // struct LDKPublicKey AcceptChannelV2_get_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30888 export function AcceptChannelV2_get_payment_basepoint(this_ptr: bigint): number {
30889 if(!isWasmInitialized) {
30890 throw new Error("initializeWasm() must be awaited first!");
30892 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_payment_basepoint(this_ptr);
30893 return nativeResponseValue;
30895 // void AcceptChannelV2_set_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30897 export function AcceptChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
30898 if(!isWasmInitialized) {
30899 throw new Error("initializeWasm() must be awaited first!");
30901 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_payment_basepoint(this_ptr, val);
30902 // debug statements here
30904 // struct LDKPublicKey AcceptChannelV2_get_delayed_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30906 export function AcceptChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
30907 if(!isWasmInitialized) {
30908 throw new Error("initializeWasm() must be awaited first!");
30910 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_delayed_payment_basepoint(this_ptr);
30911 return nativeResponseValue;
30913 // void AcceptChannelV2_set_delayed_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30915 export function AcceptChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
30916 if(!isWasmInitialized) {
30917 throw new Error("initializeWasm() must be awaited first!");
30919 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_delayed_payment_basepoint(this_ptr, val);
30920 // debug statements here
30922 // struct LDKPublicKey AcceptChannelV2_get_htlc_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30924 export function AcceptChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
30925 if(!isWasmInitialized) {
30926 throw new Error("initializeWasm() must be awaited first!");
30928 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_basepoint(this_ptr);
30929 return nativeResponseValue;
30931 // void AcceptChannelV2_set_htlc_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30933 export function AcceptChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
30934 if(!isWasmInitialized) {
30935 throw new Error("initializeWasm() must be awaited first!");
30937 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_basepoint(this_ptr, val);
30938 // debug statements here
30940 // struct LDKPublicKey AcceptChannelV2_get_first_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30942 export function AcceptChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
30943 if(!isWasmInitialized) {
30944 throw new Error("initializeWasm() must be awaited first!");
30946 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_first_per_commitment_point(this_ptr);
30947 return nativeResponseValue;
30949 // void AcceptChannelV2_set_first_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30951 export function AcceptChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
30952 if(!isWasmInitialized) {
30953 throw new Error("initializeWasm() must be awaited first!");
30955 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_first_per_commitment_point(this_ptr, val);
30956 // debug statements here
30958 // struct LDKPublicKey AcceptChannelV2_get_second_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30960 export function AcceptChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
30961 if(!isWasmInitialized) {
30962 throw new Error("initializeWasm() must be awaited first!");
30964 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_second_per_commitment_point(this_ptr);
30965 return nativeResponseValue;
30967 // void AcceptChannelV2_set_second_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30969 export function AcceptChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
30970 if(!isWasmInitialized) {
30971 throw new Error("initializeWasm() must be awaited first!");
30973 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_second_per_commitment_point(this_ptr, val);
30974 // debug statements here
30976 // struct LDKCOption_CVec_u8ZZ AcceptChannelV2_get_shutdown_scriptpubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30978 export function AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
30979 if(!isWasmInitialized) {
30980 throw new Error("initializeWasm() must be awaited first!");
30982 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr);
30983 return nativeResponseValue;
30985 // void AcceptChannelV2_set_shutdown_scriptpubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
30987 export function AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
30988 if(!isWasmInitialized) {
30989 throw new Error("initializeWasm() must be awaited first!");
30991 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
30992 // debug statements here
30994 // struct LDKChannelTypeFeatures AcceptChannelV2_get_channel_type(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
30996 export function AcceptChannelV2_get_channel_type(this_ptr: bigint): bigint {
30997 if(!isWasmInitialized) {
30998 throw new Error("initializeWasm() must be awaited first!");
31000 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_channel_type(this_ptr);
31001 return nativeResponseValue;
31003 // void AcceptChannelV2_set_channel_type(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
31005 export function AcceptChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
31006 if(!isWasmInitialized) {
31007 throw new Error("initializeWasm() must be awaited first!");
31009 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_channel_type(this_ptr, val);
31010 // debug statements here
31012 // enum LDKCOption_NoneZ AcceptChannelV2_get_require_confirmed_inputs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31014 export function AcceptChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
31015 if(!isWasmInitialized) {
31016 throw new Error("initializeWasm() must be awaited first!");
31018 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_require_confirmed_inputs(this_ptr);
31019 return nativeResponseValue;
31021 // void AcceptChannelV2_set_require_confirmed_inputs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
31023 export function AcceptChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
31024 if(!isWasmInitialized) {
31025 throw new Error("initializeWasm() must be awaited first!");
31027 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_require_confirmed_inputs(this_ptr, val);
31028 // debug statements here
31030 // 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_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
31032 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 {
31033 if(!isWasmInitialized) {
31034 throw new Error("initializeWasm() must be awaited first!");
31036 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);
31037 return nativeResponseValue;
31039 // uint64_t AcceptChannelV2_clone_ptr(LDKAcceptChannelV2 *NONNULL_PTR arg);
31041 export function AcceptChannelV2_clone_ptr(arg: bigint): bigint {
31042 if(!isWasmInitialized) {
31043 throw new Error("initializeWasm() must be awaited first!");
31045 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone_ptr(arg);
31046 return nativeResponseValue;
31048 // struct LDKAcceptChannelV2 AcceptChannelV2_clone(const struct LDKAcceptChannelV2 *NONNULL_PTR orig);
31050 export function AcceptChannelV2_clone(orig: bigint): bigint {
31051 if(!isWasmInitialized) {
31052 throw new Error("initializeWasm() must be awaited first!");
31054 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone(orig);
31055 return nativeResponseValue;
31057 // bool AcceptChannelV2_eq(const struct LDKAcceptChannelV2 *NONNULL_PTR a, const struct LDKAcceptChannelV2 *NONNULL_PTR b);
31059 export function AcceptChannelV2_eq(a: bigint, b: bigint): boolean {
31060 if(!isWasmInitialized) {
31061 throw new Error("initializeWasm() must be awaited first!");
31063 const nativeResponseValue = wasm.TS_AcceptChannelV2_eq(a, b);
31064 return nativeResponseValue;
31066 // void FundingCreated_free(struct LDKFundingCreated this_obj);
31068 export function FundingCreated_free(this_obj: bigint): void {
31069 if(!isWasmInitialized) {
31070 throw new Error("initializeWasm() must be awaited first!");
31072 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
31073 // debug statements here
31075 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
31077 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
31078 if(!isWasmInitialized) {
31079 throw new Error("initializeWasm() must be awaited first!");
31081 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
31082 return nativeResponseValue;
31084 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31086 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
31087 if(!isWasmInitialized) {
31088 throw new Error("initializeWasm() must be awaited first!");
31090 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
31091 // debug statements here
31093 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
31095 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
31096 if(!isWasmInitialized) {
31097 throw new Error("initializeWasm() must be awaited first!");
31099 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
31100 return nativeResponseValue;
31102 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31104 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
31105 if(!isWasmInitialized) {
31106 throw new Error("initializeWasm() must be awaited first!");
31108 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
31109 // debug statements here
31111 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
31113 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
31114 if(!isWasmInitialized) {
31115 throw new Error("initializeWasm() must be awaited first!");
31117 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
31118 return nativeResponseValue;
31120 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
31122 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
31123 if(!isWasmInitialized) {
31124 throw new Error("initializeWasm() must be awaited first!");
31126 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
31127 // debug statements here
31129 // struct LDKECDSASignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
31131 export function FundingCreated_get_signature(this_ptr: bigint): number {
31132 if(!isWasmInitialized) {
31133 throw new Error("initializeWasm() must be awaited first!");
31135 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
31136 return nativeResponseValue;
31138 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
31140 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
31141 if(!isWasmInitialized) {
31142 throw new Error("initializeWasm() must be awaited first!");
31144 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
31145 // debug statements here
31147 // 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 LDKECDSASignature signature_arg);
31149 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
31150 if(!isWasmInitialized) {
31151 throw new Error("initializeWasm() must be awaited first!");
31153 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
31154 return nativeResponseValue;
31156 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
31158 export function FundingCreated_clone_ptr(arg: bigint): bigint {
31159 if(!isWasmInitialized) {
31160 throw new Error("initializeWasm() must be awaited first!");
31162 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
31163 return nativeResponseValue;
31165 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
31167 export function FundingCreated_clone(orig: bigint): bigint {
31168 if(!isWasmInitialized) {
31169 throw new Error("initializeWasm() must be awaited first!");
31171 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
31172 return nativeResponseValue;
31174 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
31176 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
31177 if(!isWasmInitialized) {
31178 throw new Error("initializeWasm() must be awaited first!");
31180 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
31181 return nativeResponseValue;
31183 // void FundingSigned_free(struct LDKFundingSigned this_obj);
31185 export function FundingSigned_free(this_obj: bigint): void {
31186 if(!isWasmInitialized) {
31187 throw new Error("initializeWasm() must be awaited first!");
31189 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
31190 // debug statements here
31192 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
31194 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
31195 if(!isWasmInitialized) {
31196 throw new Error("initializeWasm() must be awaited first!");
31198 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
31199 return nativeResponseValue;
31201 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31203 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
31204 if(!isWasmInitialized) {
31205 throw new Error("initializeWasm() must be awaited first!");
31207 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
31208 // debug statements here
31210 // struct LDKECDSASignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
31212 export function FundingSigned_get_signature(this_ptr: bigint): number {
31213 if(!isWasmInitialized) {
31214 throw new Error("initializeWasm() must be awaited first!");
31216 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
31217 return nativeResponseValue;
31219 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
31221 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
31222 if(!isWasmInitialized) {
31223 throw new Error("initializeWasm() must be awaited first!");
31225 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
31226 // debug statements here
31228 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKECDSASignature signature_arg);
31230 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
31231 if(!isWasmInitialized) {
31232 throw new Error("initializeWasm() must be awaited first!");
31234 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
31235 return nativeResponseValue;
31237 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
31239 export function FundingSigned_clone_ptr(arg: bigint): bigint {
31240 if(!isWasmInitialized) {
31241 throw new Error("initializeWasm() must be awaited first!");
31243 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
31244 return nativeResponseValue;
31246 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
31248 export function FundingSigned_clone(orig: bigint): bigint {
31249 if(!isWasmInitialized) {
31250 throw new Error("initializeWasm() must be awaited first!");
31252 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
31253 return nativeResponseValue;
31255 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
31257 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
31258 if(!isWasmInitialized) {
31259 throw new Error("initializeWasm() must be awaited first!");
31261 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
31262 return nativeResponseValue;
31264 // void ChannelReady_free(struct LDKChannelReady this_obj);
31266 export function ChannelReady_free(this_obj: bigint): void {
31267 if(!isWasmInitialized) {
31268 throw new Error("initializeWasm() must be awaited first!");
31270 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
31271 // debug statements here
31273 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
31275 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
31276 if(!isWasmInitialized) {
31277 throw new Error("initializeWasm() must be awaited first!");
31279 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
31280 return nativeResponseValue;
31282 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31284 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
31285 if(!isWasmInitialized) {
31286 throw new Error("initializeWasm() must be awaited first!");
31288 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
31289 // debug statements here
31291 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
31293 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
31294 if(!isWasmInitialized) {
31295 throw new Error("initializeWasm() must be awaited first!");
31297 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
31298 return nativeResponseValue;
31300 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31302 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
31303 if(!isWasmInitialized) {
31304 throw new Error("initializeWasm() must be awaited first!");
31306 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
31307 // debug statements here
31309 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
31311 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
31312 if(!isWasmInitialized) {
31313 throw new Error("initializeWasm() must be awaited first!");
31315 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
31316 return nativeResponseValue;
31318 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31320 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
31321 if(!isWasmInitialized) {
31322 throw new Error("initializeWasm() must be awaited first!");
31324 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
31325 // debug statements here
31327 // 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);
31329 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
31330 if(!isWasmInitialized) {
31331 throw new Error("initializeWasm() must be awaited first!");
31333 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
31334 return nativeResponseValue;
31336 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
31338 export function ChannelReady_clone_ptr(arg: bigint): bigint {
31339 if(!isWasmInitialized) {
31340 throw new Error("initializeWasm() must be awaited first!");
31342 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
31343 return nativeResponseValue;
31345 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
31347 export function ChannelReady_clone(orig: bigint): bigint {
31348 if(!isWasmInitialized) {
31349 throw new Error("initializeWasm() must be awaited first!");
31351 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
31352 return nativeResponseValue;
31354 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
31356 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
31357 if(!isWasmInitialized) {
31358 throw new Error("initializeWasm() must be awaited first!");
31360 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
31361 return nativeResponseValue;
31363 // void TxAddInput_free(struct LDKTxAddInput this_obj);
31365 export function TxAddInput_free(this_obj: bigint): void {
31366 if(!isWasmInitialized) {
31367 throw new Error("initializeWasm() must be awaited first!");
31369 const nativeResponseValue = wasm.TS_TxAddInput_free(this_obj);
31370 // debug statements here
31372 // const uint8_t (*TxAddInput_get_channel_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr))[32];
31374 export function TxAddInput_get_channel_id(this_ptr: bigint): number {
31375 if(!isWasmInitialized) {
31376 throw new Error("initializeWasm() must be awaited first!");
31378 const nativeResponseValue = wasm.TS_TxAddInput_get_channel_id(this_ptr);
31379 return nativeResponseValue;
31381 // void TxAddInput_set_channel_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31383 export function TxAddInput_set_channel_id(this_ptr: bigint, val: number): void {
31384 if(!isWasmInitialized) {
31385 throw new Error("initializeWasm() must be awaited first!");
31387 const nativeResponseValue = wasm.TS_TxAddInput_set_channel_id(this_ptr, val);
31388 // debug statements here
31390 // uint64_t TxAddInput_get_serial_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31392 export function TxAddInput_get_serial_id(this_ptr: bigint): bigint {
31393 if(!isWasmInitialized) {
31394 throw new Error("initializeWasm() must be awaited first!");
31396 const nativeResponseValue = wasm.TS_TxAddInput_get_serial_id(this_ptr);
31397 return nativeResponseValue;
31399 // void TxAddInput_set_serial_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint64_t val);
31401 export function TxAddInput_set_serial_id(this_ptr: bigint, val: bigint): void {
31402 if(!isWasmInitialized) {
31403 throw new Error("initializeWasm() must be awaited first!");
31405 const nativeResponseValue = wasm.TS_TxAddInput_set_serial_id(this_ptr, val);
31406 // debug statements here
31408 // struct LDKTransactionU16LenLimited TxAddInput_get_prevtx(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31410 export function TxAddInput_get_prevtx(this_ptr: bigint): bigint {
31411 if(!isWasmInitialized) {
31412 throw new Error("initializeWasm() must be awaited first!");
31414 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx(this_ptr);
31415 return nativeResponseValue;
31417 // void TxAddInput_set_prevtx(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKTransactionU16LenLimited val);
31419 export function TxAddInput_set_prevtx(this_ptr: bigint, val: bigint): void {
31420 if(!isWasmInitialized) {
31421 throw new Error("initializeWasm() must be awaited first!");
31423 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx(this_ptr, val);
31424 // debug statements here
31426 // uint32_t TxAddInput_get_prevtx_out(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31428 export function TxAddInput_get_prevtx_out(this_ptr: bigint): number {
31429 if(!isWasmInitialized) {
31430 throw new Error("initializeWasm() must be awaited first!");
31432 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx_out(this_ptr);
31433 return nativeResponseValue;
31435 // void TxAddInput_set_prevtx_out(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
31437 export function TxAddInput_set_prevtx_out(this_ptr: bigint, val: number): void {
31438 if(!isWasmInitialized) {
31439 throw new Error("initializeWasm() must be awaited first!");
31441 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx_out(this_ptr, val);
31442 // debug statements here
31444 // uint32_t TxAddInput_get_sequence(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31446 export function TxAddInput_get_sequence(this_ptr: bigint): number {
31447 if(!isWasmInitialized) {
31448 throw new Error("initializeWasm() must be awaited first!");
31450 const nativeResponseValue = wasm.TS_TxAddInput_get_sequence(this_ptr);
31451 return nativeResponseValue;
31453 // void TxAddInput_set_sequence(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
31455 export function TxAddInput_set_sequence(this_ptr: bigint, val: number): void {
31456 if(!isWasmInitialized) {
31457 throw new Error("initializeWasm() must be awaited first!");
31459 const nativeResponseValue = wasm.TS_TxAddInput_set_sequence(this_ptr, val);
31460 // debug statements here
31462 // 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);
31464 export function TxAddInput_new(channel_id_arg: number, serial_id_arg: bigint, prevtx_arg: bigint, prevtx_out_arg: number, sequence_arg: number): bigint {
31465 if(!isWasmInitialized) {
31466 throw new Error("initializeWasm() must be awaited first!");
31468 const nativeResponseValue = wasm.TS_TxAddInput_new(channel_id_arg, serial_id_arg, prevtx_arg, prevtx_out_arg, sequence_arg);
31469 return nativeResponseValue;
31471 // uint64_t TxAddInput_clone_ptr(LDKTxAddInput *NONNULL_PTR arg);
31473 export function TxAddInput_clone_ptr(arg: bigint): bigint {
31474 if(!isWasmInitialized) {
31475 throw new Error("initializeWasm() must be awaited first!");
31477 const nativeResponseValue = wasm.TS_TxAddInput_clone_ptr(arg);
31478 return nativeResponseValue;
31480 // struct LDKTxAddInput TxAddInput_clone(const struct LDKTxAddInput *NONNULL_PTR orig);
31482 export function TxAddInput_clone(orig: bigint): bigint {
31483 if(!isWasmInitialized) {
31484 throw new Error("initializeWasm() must be awaited first!");
31486 const nativeResponseValue = wasm.TS_TxAddInput_clone(orig);
31487 return nativeResponseValue;
31489 // bool TxAddInput_eq(const struct LDKTxAddInput *NONNULL_PTR a, const struct LDKTxAddInput *NONNULL_PTR b);
31491 export function TxAddInput_eq(a: bigint, b: bigint): boolean {
31492 if(!isWasmInitialized) {
31493 throw new Error("initializeWasm() must be awaited first!");
31495 const nativeResponseValue = wasm.TS_TxAddInput_eq(a, b);
31496 return nativeResponseValue;
31498 // void TxAddOutput_free(struct LDKTxAddOutput this_obj);
31500 export function TxAddOutput_free(this_obj: bigint): void {
31501 if(!isWasmInitialized) {
31502 throw new Error("initializeWasm() must be awaited first!");
31504 const nativeResponseValue = wasm.TS_TxAddOutput_free(this_obj);
31505 // debug statements here
31507 // const uint8_t (*TxAddOutput_get_channel_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr))[32];
31509 export function TxAddOutput_get_channel_id(this_ptr: bigint): number {
31510 if(!isWasmInitialized) {
31511 throw new Error("initializeWasm() must be awaited first!");
31513 const nativeResponseValue = wasm.TS_TxAddOutput_get_channel_id(this_ptr);
31514 return nativeResponseValue;
31516 // void TxAddOutput_set_channel_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31518 export function TxAddOutput_set_channel_id(this_ptr: bigint, val: number): void {
31519 if(!isWasmInitialized) {
31520 throw new Error("initializeWasm() must be awaited first!");
31522 const nativeResponseValue = wasm.TS_TxAddOutput_set_channel_id(this_ptr, val);
31523 // debug statements here
31525 // uint64_t TxAddOutput_get_serial_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
31527 export function TxAddOutput_get_serial_id(this_ptr: bigint): bigint {
31528 if(!isWasmInitialized) {
31529 throw new Error("initializeWasm() must be awaited first!");
31531 const nativeResponseValue = wasm.TS_TxAddOutput_get_serial_id(this_ptr);
31532 return nativeResponseValue;
31534 // void TxAddOutput_set_serial_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
31536 export function TxAddOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
31537 if(!isWasmInitialized) {
31538 throw new Error("initializeWasm() must be awaited first!");
31540 const nativeResponseValue = wasm.TS_TxAddOutput_set_serial_id(this_ptr, val);
31541 // debug statements here
31543 // uint64_t TxAddOutput_get_sats(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
31545 export function TxAddOutput_get_sats(this_ptr: bigint): bigint {
31546 if(!isWasmInitialized) {
31547 throw new Error("initializeWasm() must be awaited first!");
31549 const nativeResponseValue = wasm.TS_TxAddOutput_get_sats(this_ptr);
31550 return nativeResponseValue;
31552 // void TxAddOutput_set_sats(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
31554 export function TxAddOutput_set_sats(this_ptr: bigint, val: bigint): void {
31555 if(!isWasmInitialized) {
31556 throw new Error("initializeWasm() must be awaited first!");
31558 const nativeResponseValue = wasm.TS_TxAddOutput_set_sats(this_ptr, val);
31559 // debug statements here
31561 // struct LDKu8slice TxAddOutput_get_script(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
31563 export function TxAddOutput_get_script(this_ptr: bigint): number {
31564 if(!isWasmInitialized) {
31565 throw new Error("initializeWasm() must be awaited first!");
31567 const nativeResponseValue = wasm.TS_TxAddOutput_get_script(this_ptr);
31568 return nativeResponseValue;
31570 // void TxAddOutput_set_script(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
31572 export function TxAddOutput_set_script(this_ptr: bigint, val: number): void {
31573 if(!isWasmInitialized) {
31574 throw new Error("initializeWasm() must be awaited first!");
31576 const nativeResponseValue = wasm.TS_TxAddOutput_set_script(this_ptr, val);
31577 // debug statements here
31579 // 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);
31581 export function TxAddOutput_new(channel_id_arg: number, serial_id_arg: bigint, sats_arg: bigint, script_arg: number): bigint {
31582 if(!isWasmInitialized) {
31583 throw new Error("initializeWasm() must be awaited first!");
31585 const nativeResponseValue = wasm.TS_TxAddOutput_new(channel_id_arg, serial_id_arg, sats_arg, script_arg);
31586 return nativeResponseValue;
31588 // uint64_t TxAddOutput_clone_ptr(LDKTxAddOutput *NONNULL_PTR arg);
31590 export function TxAddOutput_clone_ptr(arg: bigint): bigint {
31591 if(!isWasmInitialized) {
31592 throw new Error("initializeWasm() must be awaited first!");
31594 const nativeResponseValue = wasm.TS_TxAddOutput_clone_ptr(arg);
31595 return nativeResponseValue;
31597 // struct LDKTxAddOutput TxAddOutput_clone(const struct LDKTxAddOutput *NONNULL_PTR orig);
31599 export function TxAddOutput_clone(orig: bigint): bigint {
31600 if(!isWasmInitialized) {
31601 throw new Error("initializeWasm() must be awaited first!");
31603 const nativeResponseValue = wasm.TS_TxAddOutput_clone(orig);
31604 return nativeResponseValue;
31606 // bool TxAddOutput_eq(const struct LDKTxAddOutput *NONNULL_PTR a, const struct LDKTxAddOutput *NONNULL_PTR b);
31608 export function TxAddOutput_eq(a: bigint, b: bigint): boolean {
31609 if(!isWasmInitialized) {
31610 throw new Error("initializeWasm() must be awaited first!");
31612 const nativeResponseValue = wasm.TS_TxAddOutput_eq(a, b);
31613 return nativeResponseValue;
31615 // void TxRemoveInput_free(struct LDKTxRemoveInput this_obj);
31617 export function TxRemoveInput_free(this_obj: bigint): void {
31618 if(!isWasmInitialized) {
31619 throw new Error("initializeWasm() must be awaited first!");
31621 const nativeResponseValue = wasm.TS_TxRemoveInput_free(this_obj);
31622 // debug statements here
31624 // const uint8_t (*TxRemoveInput_get_channel_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr))[32];
31626 export function TxRemoveInput_get_channel_id(this_ptr: bigint): number {
31627 if(!isWasmInitialized) {
31628 throw new Error("initializeWasm() must be awaited first!");
31630 const nativeResponseValue = wasm.TS_TxRemoveInput_get_channel_id(this_ptr);
31631 return nativeResponseValue;
31633 // void TxRemoveInput_set_channel_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31635 export function TxRemoveInput_set_channel_id(this_ptr: bigint, val: number): void {
31636 if(!isWasmInitialized) {
31637 throw new Error("initializeWasm() must be awaited first!");
31639 const nativeResponseValue = wasm.TS_TxRemoveInput_set_channel_id(this_ptr, val);
31640 // debug statements here
31642 // uint64_t TxRemoveInput_get_serial_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr);
31644 export function TxRemoveInput_get_serial_id(this_ptr: bigint): bigint {
31645 if(!isWasmInitialized) {
31646 throw new Error("initializeWasm() must be awaited first!");
31648 const nativeResponseValue = wasm.TS_TxRemoveInput_get_serial_id(this_ptr);
31649 return nativeResponseValue;
31651 // void TxRemoveInput_set_serial_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, uint64_t val);
31653 export function TxRemoveInput_set_serial_id(this_ptr: bigint, val: bigint): void {
31654 if(!isWasmInitialized) {
31655 throw new Error("initializeWasm() must be awaited first!");
31657 const nativeResponseValue = wasm.TS_TxRemoveInput_set_serial_id(this_ptr, val);
31658 // debug statements here
31660 // MUST_USE_RES struct LDKTxRemoveInput TxRemoveInput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
31662 export function TxRemoveInput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
31663 if(!isWasmInitialized) {
31664 throw new Error("initializeWasm() must be awaited first!");
31666 const nativeResponseValue = wasm.TS_TxRemoveInput_new(channel_id_arg, serial_id_arg);
31667 return nativeResponseValue;
31669 // uint64_t TxRemoveInput_clone_ptr(LDKTxRemoveInput *NONNULL_PTR arg);
31671 export function TxRemoveInput_clone_ptr(arg: bigint): bigint {
31672 if(!isWasmInitialized) {
31673 throw new Error("initializeWasm() must be awaited first!");
31675 const nativeResponseValue = wasm.TS_TxRemoveInput_clone_ptr(arg);
31676 return nativeResponseValue;
31678 // struct LDKTxRemoveInput TxRemoveInput_clone(const struct LDKTxRemoveInput *NONNULL_PTR orig);
31680 export function TxRemoveInput_clone(orig: bigint): bigint {
31681 if(!isWasmInitialized) {
31682 throw new Error("initializeWasm() must be awaited first!");
31684 const nativeResponseValue = wasm.TS_TxRemoveInput_clone(orig);
31685 return nativeResponseValue;
31687 // bool TxRemoveInput_eq(const struct LDKTxRemoveInput *NONNULL_PTR a, const struct LDKTxRemoveInput *NONNULL_PTR b);
31689 export function TxRemoveInput_eq(a: bigint, b: bigint): boolean {
31690 if(!isWasmInitialized) {
31691 throw new Error("initializeWasm() must be awaited first!");
31693 const nativeResponseValue = wasm.TS_TxRemoveInput_eq(a, b);
31694 return nativeResponseValue;
31696 // void TxRemoveOutput_free(struct LDKTxRemoveOutput this_obj);
31698 export function TxRemoveOutput_free(this_obj: bigint): void {
31699 if(!isWasmInitialized) {
31700 throw new Error("initializeWasm() must be awaited first!");
31702 const nativeResponseValue = wasm.TS_TxRemoveOutput_free(this_obj);
31703 // debug statements here
31705 // const uint8_t (*TxRemoveOutput_get_channel_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr))[32];
31707 export function TxRemoveOutput_get_channel_id(this_ptr: bigint): number {
31708 if(!isWasmInitialized) {
31709 throw new Error("initializeWasm() must be awaited first!");
31711 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_channel_id(this_ptr);
31712 return nativeResponseValue;
31714 // void TxRemoveOutput_set_channel_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31716 export function TxRemoveOutput_set_channel_id(this_ptr: bigint, val: number): void {
31717 if(!isWasmInitialized) {
31718 throw new Error("initializeWasm() must be awaited first!");
31720 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_channel_id(this_ptr, val);
31721 // debug statements here
31723 // uint64_t TxRemoveOutput_get_serial_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr);
31725 export function TxRemoveOutput_get_serial_id(this_ptr: bigint): bigint {
31726 if(!isWasmInitialized) {
31727 throw new Error("initializeWasm() must be awaited first!");
31729 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_serial_id(this_ptr);
31730 return nativeResponseValue;
31732 // void TxRemoveOutput_set_serial_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, uint64_t val);
31734 export function TxRemoveOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
31735 if(!isWasmInitialized) {
31736 throw new Error("initializeWasm() must be awaited first!");
31738 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_serial_id(this_ptr, val);
31739 // debug statements here
31741 // MUST_USE_RES struct LDKTxRemoveOutput TxRemoveOutput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
31743 export function TxRemoveOutput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
31744 if(!isWasmInitialized) {
31745 throw new Error("initializeWasm() must be awaited first!");
31747 const nativeResponseValue = wasm.TS_TxRemoveOutput_new(channel_id_arg, serial_id_arg);
31748 return nativeResponseValue;
31750 // uint64_t TxRemoveOutput_clone_ptr(LDKTxRemoveOutput *NONNULL_PTR arg);
31752 export function TxRemoveOutput_clone_ptr(arg: bigint): bigint {
31753 if(!isWasmInitialized) {
31754 throw new Error("initializeWasm() must be awaited first!");
31756 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone_ptr(arg);
31757 return nativeResponseValue;
31759 // struct LDKTxRemoveOutput TxRemoveOutput_clone(const struct LDKTxRemoveOutput *NONNULL_PTR orig);
31761 export function TxRemoveOutput_clone(orig: bigint): bigint {
31762 if(!isWasmInitialized) {
31763 throw new Error("initializeWasm() must be awaited first!");
31765 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone(orig);
31766 return nativeResponseValue;
31768 // bool TxRemoveOutput_eq(const struct LDKTxRemoveOutput *NONNULL_PTR a, const struct LDKTxRemoveOutput *NONNULL_PTR b);
31770 export function TxRemoveOutput_eq(a: bigint, b: bigint): boolean {
31771 if(!isWasmInitialized) {
31772 throw new Error("initializeWasm() must be awaited first!");
31774 const nativeResponseValue = wasm.TS_TxRemoveOutput_eq(a, b);
31775 return nativeResponseValue;
31777 // void TxComplete_free(struct LDKTxComplete this_obj);
31779 export function TxComplete_free(this_obj: bigint): void {
31780 if(!isWasmInitialized) {
31781 throw new Error("initializeWasm() must be awaited first!");
31783 const nativeResponseValue = wasm.TS_TxComplete_free(this_obj);
31784 // debug statements here
31786 // const uint8_t (*TxComplete_get_channel_id(const struct LDKTxComplete *NONNULL_PTR this_ptr))[32];
31788 export function TxComplete_get_channel_id(this_ptr: bigint): number {
31789 if(!isWasmInitialized) {
31790 throw new Error("initializeWasm() must be awaited first!");
31792 const nativeResponseValue = wasm.TS_TxComplete_get_channel_id(this_ptr);
31793 return nativeResponseValue;
31795 // void TxComplete_set_channel_id(struct LDKTxComplete *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31797 export function TxComplete_set_channel_id(this_ptr: bigint, val: number): void {
31798 if(!isWasmInitialized) {
31799 throw new Error("initializeWasm() must be awaited first!");
31801 const nativeResponseValue = wasm.TS_TxComplete_set_channel_id(this_ptr, val);
31802 // debug statements here
31804 // MUST_USE_RES struct LDKTxComplete TxComplete_new(struct LDKThirtyTwoBytes channel_id_arg);
31806 export function TxComplete_new(channel_id_arg: number): bigint {
31807 if(!isWasmInitialized) {
31808 throw new Error("initializeWasm() must be awaited first!");
31810 const nativeResponseValue = wasm.TS_TxComplete_new(channel_id_arg);
31811 return nativeResponseValue;
31813 // uint64_t TxComplete_clone_ptr(LDKTxComplete *NONNULL_PTR arg);
31815 export function TxComplete_clone_ptr(arg: bigint): bigint {
31816 if(!isWasmInitialized) {
31817 throw new Error("initializeWasm() must be awaited first!");
31819 const nativeResponseValue = wasm.TS_TxComplete_clone_ptr(arg);
31820 return nativeResponseValue;
31822 // struct LDKTxComplete TxComplete_clone(const struct LDKTxComplete *NONNULL_PTR orig);
31824 export function TxComplete_clone(orig: bigint): bigint {
31825 if(!isWasmInitialized) {
31826 throw new Error("initializeWasm() must be awaited first!");
31828 const nativeResponseValue = wasm.TS_TxComplete_clone(orig);
31829 return nativeResponseValue;
31831 // bool TxComplete_eq(const struct LDKTxComplete *NONNULL_PTR a, const struct LDKTxComplete *NONNULL_PTR b);
31833 export function TxComplete_eq(a: bigint, b: bigint): boolean {
31834 if(!isWasmInitialized) {
31835 throw new Error("initializeWasm() must be awaited first!");
31837 const nativeResponseValue = wasm.TS_TxComplete_eq(a, b);
31838 return nativeResponseValue;
31840 // void TxSignatures_free(struct LDKTxSignatures this_obj);
31842 export function TxSignatures_free(this_obj: bigint): void {
31843 if(!isWasmInitialized) {
31844 throw new Error("initializeWasm() must be awaited first!");
31846 const nativeResponseValue = wasm.TS_TxSignatures_free(this_obj);
31847 // debug statements here
31849 // const uint8_t (*TxSignatures_get_channel_id(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
31851 export function TxSignatures_get_channel_id(this_ptr: bigint): number {
31852 if(!isWasmInitialized) {
31853 throw new Error("initializeWasm() must be awaited first!");
31855 const nativeResponseValue = wasm.TS_TxSignatures_get_channel_id(this_ptr);
31856 return nativeResponseValue;
31858 // void TxSignatures_set_channel_id(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31860 export function TxSignatures_set_channel_id(this_ptr: bigint, val: number): void {
31861 if(!isWasmInitialized) {
31862 throw new Error("initializeWasm() must be awaited first!");
31864 const nativeResponseValue = wasm.TS_TxSignatures_set_channel_id(this_ptr, val);
31865 // debug statements here
31867 // const uint8_t (*TxSignatures_get_tx_hash(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
31869 export function TxSignatures_get_tx_hash(this_ptr: bigint): number {
31870 if(!isWasmInitialized) {
31871 throw new Error("initializeWasm() must be awaited first!");
31873 const nativeResponseValue = wasm.TS_TxSignatures_get_tx_hash(this_ptr);
31874 return nativeResponseValue;
31876 // void TxSignatures_set_tx_hash(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31878 export function TxSignatures_set_tx_hash(this_ptr: bigint, val: number): void {
31879 if(!isWasmInitialized) {
31880 throw new Error("initializeWasm() must be awaited first!");
31882 const nativeResponseValue = wasm.TS_TxSignatures_set_tx_hash(this_ptr, val);
31883 // debug statements here
31885 // struct LDKCVec_WitnessZ TxSignatures_get_witnesses(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
31887 export function TxSignatures_get_witnesses(this_ptr: bigint): number {
31888 if(!isWasmInitialized) {
31889 throw new Error("initializeWasm() must be awaited first!");
31891 const nativeResponseValue = wasm.TS_TxSignatures_get_witnesses(this_ptr);
31892 return nativeResponseValue;
31894 // void TxSignatures_set_witnesses(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKCVec_WitnessZ val);
31896 export function TxSignatures_set_witnesses(this_ptr: bigint, val: number): void {
31897 if(!isWasmInitialized) {
31898 throw new Error("initializeWasm() must be awaited first!");
31900 const nativeResponseValue = wasm.TS_TxSignatures_set_witnesses(this_ptr, val);
31901 // debug statements here
31903 // MUST_USE_RES struct LDKTxSignatures TxSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes tx_hash_arg, struct LDKCVec_WitnessZ witnesses_arg);
31905 export function TxSignatures_new(channel_id_arg: number, tx_hash_arg: number, witnesses_arg: number): bigint {
31906 if(!isWasmInitialized) {
31907 throw new Error("initializeWasm() must be awaited first!");
31909 const nativeResponseValue = wasm.TS_TxSignatures_new(channel_id_arg, tx_hash_arg, witnesses_arg);
31910 return nativeResponseValue;
31912 // uint64_t TxSignatures_clone_ptr(LDKTxSignatures *NONNULL_PTR arg);
31914 export function TxSignatures_clone_ptr(arg: bigint): bigint {
31915 if(!isWasmInitialized) {
31916 throw new Error("initializeWasm() must be awaited first!");
31918 const nativeResponseValue = wasm.TS_TxSignatures_clone_ptr(arg);
31919 return nativeResponseValue;
31921 // struct LDKTxSignatures TxSignatures_clone(const struct LDKTxSignatures *NONNULL_PTR orig);
31923 export function TxSignatures_clone(orig: bigint): bigint {
31924 if(!isWasmInitialized) {
31925 throw new Error("initializeWasm() must be awaited first!");
31927 const nativeResponseValue = wasm.TS_TxSignatures_clone(orig);
31928 return nativeResponseValue;
31930 // bool TxSignatures_eq(const struct LDKTxSignatures *NONNULL_PTR a, const struct LDKTxSignatures *NONNULL_PTR b);
31932 export function TxSignatures_eq(a: bigint, b: bigint): boolean {
31933 if(!isWasmInitialized) {
31934 throw new Error("initializeWasm() must be awaited first!");
31936 const nativeResponseValue = wasm.TS_TxSignatures_eq(a, b);
31937 return nativeResponseValue;
31939 // void TxInitRbf_free(struct LDKTxInitRbf this_obj);
31941 export function TxInitRbf_free(this_obj: bigint): void {
31942 if(!isWasmInitialized) {
31943 throw new Error("initializeWasm() must be awaited first!");
31945 const nativeResponseValue = wasm.TS_TxInitRbf_free(this_obj);
31946 // debug statements here
31948 // const uint8_t (*TxInitRbf_get_channel_id(const struct LDKTxInitRbf *NONNULL_PTR this_ptr))[32];
31950 export function TxInitRbf_get_channel_id(this_ptr: bigint): number {
31951 if(!isWasmInitialized) {
31952 throw new Error("initializeWasm() must be awaited first!");
31954 const nativeResponseValue = wasm.TS_TxInitRbf_get_channel_id(this_ptr);
31955 return nativeResponseValue;
31957 // void TxInitRbf_set_channel_id(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31959 export function TxInitRbf_set_channel_id(this_ptr: bigint, val: number): void {
31960 if(!isWasmInitialized) {
31961 throw new Error("initializeWasm() must be awaited first!");
31963 const nativeResponseValue = wasm.TS_TxInitRbf_set_channel_id(this_ptr, val);
31964 // debug statements here
31966 // uint32_t TxInitRbf_get_locktime(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
31968 export function TxInitRbf_get_locktime(this_ptr: bigint): number {
31969 if(!isWasmInitialized) {
31970 throw new Error("initializeWasm() must be awaited first!");
31972 const nativeResponseValue = wasm.TS_TxInitRbf_get_locktime(this_ptr);
31973 return nativeResponseValue;
31975 // void TxInitRbf_set_locktime(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
31977 export function TxInitRbf_set_locktime(this_ptr: bigint, val: number): void {
31978 if(!isWasmInitialized) {
31979 throw new Error("initializeWasm() must be awaited first!");
31981 const nativeResponseValue = wasm.TS_TxInitRbf_set_locktime(this_ptr, val);
31982 // debug statements here
31984 // uint32_t TxInitRbf_get_feerate_sat_per_1000_weight(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
31986 export function TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: bigint): number {
31987 if(!isWasmInitialized) {
31988 throw new Error("initializeWasm() must be awaited first!");
31990 const nativeResponseValue = wasm.TS_TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr);
31991 return nativeResponseValue;
31993 // void TxInitRbf_set_feerate_sat_per_1000_weight(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
31995 export function TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
31996 if(!isWasmInitialized) {
31997 throw new Error("initializeWasm() must be awaited first!");
31999 const nativeResponseValue = wasm.TS_TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr, val);
32000 // debug statements here
32002 // struct LDKCOption_i64Z TxInitRbf_get_funding_output_contribution(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
32004 export function TxInitRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
32005 if(!isWasmInitialized) {
32006 throw new Error("initializeWasm() must be awaited first!");
32008 const nativeResponseValue = wasm.TS_TxInitRbf_get_funding_output_contribution(this_ptr);
32009 return nativeResponseValue;
32011 // void TxInitRbf_set_funding_output_contribution(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
32013 export function TxInitRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
32014 if(!isWasmInitialized) {
32015 throw new Error("initializeWasm() must be awaited first!");
32017 const nativeResponseValue = wasm.TS_TxInitRbf_set_funding_output_contribution(this_ptr, val);
32018 // debug statements here
32020 // 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);
32022 export function TxInitRbf_new(channel_id_arg: number, locktime_arg: number, feerate_sat_per_1000_weight_arg: number, funding_output_contribution_arg: bigint): bigint {
32023 if(!isWasmInitialized) {
32024 throw new Error("initializeWasm() must be awaited first!");
32026 const nativeResponseValue = wasm.TS_TxInitRbf_new(channel_id_arg, locktime_arg, feerate_sat_per_1000_weight_arg, funding_output_contribution_arg);
32027 return nativeResponseValue;
32029 // uint64_t TxInitRbf_clone_ptr(LDKTxInitRbf *NONNULL_PTR arg);
32031 export function TxInitRbf_clone_ptr(arg: bigint): bigint {
32032 if(!isWasmInitialized) {
32033 throw new Error("initializeWasm() must be awaited first!");
32035 const nativeResponseValue = wasm.TS_TxInitRbf_clone_ptr(arg);
32036 return nativeResponseValue;
32038 // struct LDKTxInitRbf TxInitRbf_clone(const struct LDKTxInitRbf *NONNULL_PTR orig);
32040 export function TxInitRbf_clone(orig: bigint): bigint {
32041 if(!isWasmInitialized) {
32042 throw new Error("initializeWasm() must be awaited first!");
32044 const nativeResponseValue = wasm.TS_TxInitRbf_clone(orig);
32045 return nativeResponseValue;
32047 // bool TxInitRbf_eq(const struct LDKTxInitRbf *NONNULL_PTR a, const struct LDKTxInitRbf *NONNULL_PTR b);
32049 export function TxInitRbf_eq(a: bigint, b: bigint): boolean {
32050 if(!isWasmInitialized) {
32051 throw new Error("initializeWasm() must be awaited first!");
32053 const nativeResponseValue = wasm.TS_TxInitRbf_eq(a, b);
32054 return nativeResponseValue;
32056 // void TxAckRbf_free(struct LDKTxAckRbf this_obj);
32058 export function TxAckRbf_free(this_obj: bigint): void {
32059 if(!isWasmInitialized) {
32060 throw new Error("initializeWasm() must be awaited first!");
32062 const nativeResponseValue = wasm.TS_TxAckRbf_free(this_obj);
32063 // debug statements here
32065 // const uint8_t (*TxAckRbf_get_channel_id(const struct LDKTxAckRbf *NONNULL_PTR this_ptr))[32];
32067 export function TxAckRbf_get_channel_id(this_ptr: bigint): number {
32068 if(!isWasmInitialized) {
32069 throw new Error("initializeWasm() must be awaited first!");
32071 const nativeResponseValue = wasm.TS_TxAckRbf_get_channel_id(this_ptr);
32072 return nativeResponseValue;
32074 // void TxAckRbf_set_channel_id(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32076 export function TxAckRbf_set_channel_id(this_ptr: bigint, val: number): void {
32077 if(!isWasmInitialized) {
32078 throw new Error("initializeWasm() must be awaited first!");
32080 const nativeResponseValue = wasm.TS_TxAckRbf_set_channel_id(this_ptr, val);
32081 // debug statements here
32083 // struct LDKCOption_i64Z TxAckRbf_get_funding_output_contribution(const struct LDKTxAckRbf *NONNULL_PTR this_ptr);
32085 export function TxAckRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
32086 if(!isWasmInitialized) {
32087 throw new Error("initializeWasm() must be awaited first!");
32089 const nativeResponseValue = wasm.TS_TxAckRbf_get_funding_output_contribution(this_ptr);
32090 return nativeResponseValue;
32092 // void TxAckRbf_set_funding_output_contribution(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
32094 export function TxAckRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
32095 if(!isWasmInitialized) {
32096 throw new Error("initializeWasm() must be awaited first!");
32098 const nativeResponseValue = wasm.TS_TxAckRbf_set_funding_output_contribution(this_ptr, val);
32099 // debug statements here
32101 // MUST_USE_RES struct LDKTxAckRbf TxAckRbf_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
32103 export function TxAckRbf_new(channel_id_arg: number, funding_output_contribution_arg: bigint): bigint {
32104 if(!isWasmInitialized) {
32105 throw new Error("initializeWasm() must be awaited first!");
32107 const nativeResponseValue = wasm.TS_TxAckRbf_new(channel_id_arg, funding_output_contribution_arg);
32108 return nativeResponseValue;
32110 // uint64_t TxAckRbf_clone_ptr(LDKTxAckRbf *NONNULL_PTR arg);
32112 export function TxAckRbf_clone_ptr(arg: bigint): bigint {
32113 if(!isWasmInitialized) {
32114 throw new Error("initializeWasm() must be awaited first!");
32116 const nativeResponseValue = wasm.TS_TxAckRbf_clone_ptr(arg);
32117 return nativeResponseValue;
32119 // struct LDKTxAckRbf TxAckRbf_clone(const struct LDKTxAckRbf *NONNULL_PTR orig);
32121 export function TxAckRbf_clone(orig: bigint): bigint {
32122 if(!isWasmInitialized) {
32123 throw new Error("initializeWasm() must be awaited first!");
32125 const nativeResponseValue = wasm.TS_TxAckRbf_clone(orig);
32126 return nativeResponseValue;
32128 // bool TxAckRbf_eq(const struct LDKTxAckRbf *NONNULL_PTR a, const struct LDKTxAckRbf *NONNULL_PTR b);
32130 export function TxAckRbf_eq(a: bigint, b: bigint): boolean {
32131 if(!isWasmInitialized) {
32132 throw new Error("initializeWasm() must be awaited first!");
32134 const nativeResponseValue = wasm.TS_TxAckRbf_eq(a, b);
32135 return nativeResponseValue;
32137 // void TxAbort_free(struct LDKTxAbort this_obj);
32139 export function TxAbort_free(this_obj: bigint): void {
32140 if(!isWasmInitialized) {
32141 throw new Error("initializeWasm() must be awaited first!");
32143 const nativeResponseValue = wasm.TS_TxAbort_free(this_obj);
32144 // debug statements here
32146 // const uint8_t (*TxAbort_get_channel_id(const struct LDKTxAbort *NONNULL_PTR this_ptr))[32];
32148 export function TxAbort_get_channel_id(this_ptr: bigint): number {
32149 if(!isWasmInitialized) {
32150 throw new Error("initializeWasm() must be awaited first!");
32152 const nativeResponseValue = wasm.TS_TxAbort_get_channel_id(this_ptr);
32153 return nativeResponseValue;
32155 // void TxAbort_set_channel_id(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32157 export function TxAbort_set_channel_id(this_ptr: bigint, val: number): void {
32158 if(!isWasmInitialized) {
32159 throw new Error("initializeWasm() must be awaited first!");
32161 const nativeResponseValue = wasm.TS_TxAbort_set_channel_id(this_ptr, val);
32162 // debug statements here
32164 // struct LDKCVec_u8Z TxAbort_get_data(const struct LDKTxAbort *NONNULL_PTR this_ptr);
32166 export function TxAbort_get_data(this_ptr: bigint): number {
32167 if(!isWasmInitialized) {
32168 throw new Error("initializeWasm() must be awaited first!");
32170 const nativeResponseValue = wasm.TS_TxAbort_get_data(this_ptr);
32171 return nativeResponseValue;
32173 // void TxAbort_set_data(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32175 export function TxAbort_set_data(this_ptr: bigint, val: number): void {
32176 if(!isWasmInitialized) {
32177 throw new Error("initializeWasm() must be awaited first!");
32179 const nativeResponseValue = wasm.TS_TxAbort_set_data(this_ptr, val);
32180 // debug statements here
32182 // MUST_USE_RES struct LDKTxAbort TxAbort_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z data_arg);
32184 export function TxAbort_new(channel_id_arg: number, data_arg: number): bigint {
32185 if(!isWasmInitialized) {
32186 throw new Error("initializeWasm() must be awaited first!");
32188 const nativeResponseValue = wasm.TS_TxAbort_new(channel_id_arg, data_arg);
32189 return nativeResponseValue;
32191 // uint64_t TxAbort_clone_ptr(LDKTxAbort *NONNULL_PTR arg);
32193 export function TxAbort_clone_ptr(arg: bigint): bigint {
32194 if(!isWasmInitialized) {
32195 throw new Error("initializeWasm() must be awaited first!");
32197 const nativeResponseValue = wasm.TS_TxAbort_clone_ptr(arg);
32198 return nativeResponseValue;
32200 // struct LDKTxAbort TxAbort_clone(const struct LDKTxAbort *NONNULL_PTR orig);
32202 export function TxAbort_clone(orig: bigint): bigint {
32203 if(!isWasmInitialized) {
32204 throw new Error("initializeWasm() must be awaited first!");
32206 const nativeResponseValue = wasm.TS_TxAbort_clone(orig);
32207 return nativeResponseValue;
32209 // bool TxAbort_eq(const struct LDKTxAbort *NONNULL_PTR a, const struct LDKTxAbort *NONNULL_PTR b);
32211 export function TxAbort_eq(a: bigint, b: bigint): boolean {
32212 if(!isWasmInitialized) {
32213 throw new Error("initializeWasm() must be awaited first!");
32215 const nativeResponseValue = wasm.TS_TxAbort_eq(a, b);
32216 return nativeResponseValue;
32218 // void Shutdown_free(struct LDKShutdown this_obj);
32220 export function Shutdown_free(this_obj: bigint): void {
32221 if(!isWasmInitialized) {
32222 throw new Error("initializeWasm() must be awaited first!");
32224 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
32225 // debug statements here
32227 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
32229 export function Shutdown_get_channel_id(this_ptr: bigint): number {
32230 if(!isWasmInitialized) {
32231 throw new Error("initializeWasm() must be awaited first!");
32233 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
32234 return nativeResponseValue;
32236 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32238 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
32239 if(!isWasmInitialized) {
32240 throw new Error("initializeWasm() must be awaited first!");
32242 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
32243 // debug statements here
32245 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
32247 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
32248 if(!isWasmInitialized) {
32249 throw new Error("initializeWasm() must be awaited first!");
32251 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
32252 return nativeResponseValue;
32254 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32256 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
32257 if(!isWasmInitialized) {
32258 throw new Error("initializeWasm() must be awaited first!");
32260 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
32261 // debug statements here
32263 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
32265 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
32266 if(!isWasmInitialized) {
32267 throw new Error("initializeWasm() must be awaited first!");
32269 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
32270 return nativeResponseValue;
32272 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
32274 export function Shutdown_clone_ptr(arg: bigint): bigint {
32275 if(!isWasmInitialized) {
32276 throw new Error("initializeWasm() must be awaited first!");
32278 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
32279 return nativeResponseValue;
32281 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
32283 export function Shutdown_clone(orig: bigint): bigint {
32284 if(!isWasmInitialized) {
32285 throw new Error("initializeWasm() must be awaited first!");
32287 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
32288 return nativeResponseValue;
32290 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
32292 export function Shutdown_eq(a: bigint, b: bigint): boolean {
32293 if(!isWasmInitialized) {
32294 throw new Error("initializeWasm() must be awaited first!");
32296 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
32297 return nativeResponseValue;
32299 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
32301 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
32302 if(!isWasmInitialized) {
32303 throw new Error("initializeWasm() must be awaited first!");
32305 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
32306 // debug statements here
32308 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
32310 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
32311 if(!isWasmInitialized) {
32312 throw new Error("initializeWasm() must be awaited first!");
32314 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
32315 return nativeResponseValue;
32317 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
32319 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
32320 if(!isWasmInitialized) {
32321 throw new Error("initializeWasm() must be awaited first!");
32323 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
32324 // debug statements here
32326 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
32328 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
32329 if(!isWasmInitialized) {
32330 throw new Error("initializeWasm() must be awaited first!");
32332 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
32333 return nativeResponseValue;
32335 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
32337 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
32338 if(!isWasmInitialized) {
32339 throw new Error("initializeWasm() must be awaited first!");
32341 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
32342 // debug statements here
32344 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
32346 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
32347 if(!isWasmInitialized) {
32348 throw new Error("initializeWasm() must be awaited first!");
32350 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
32351 return nativeResponseValue;
32353 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
32355 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
32356 if(!isWasmInitialized) {
32357 throw new Error("initializeWasm() must be awaited first!");
32359 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
32360 return nativeResponseValue;
32362 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
32364 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
32365 if(!isWasmInitialized) {
32366 throw new Error("initializeWasm() must be awaited first!");
32368 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
32369 return nativeResponseValue;
32371 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
32373 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
32374 if(!isWasmInitialized) {
32375 throw new Error("initializeWasm() must be awaited first!");
32377 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
32378 return nativeResponseValue;
32380 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
32382 export function ClosingSigned_free(this_obj: bigint): void {
32383 if(!isWasmInitialized) {
32384 throw new Error("initializeWasm() must be awaited first!");
32386 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
32387 // debug statements here
32389 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
32391 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
32392 if(!isWasmInitialized) {
32393 throw new Error("initializeWasm() must be awaited first!");
32395 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
32396 return nativeResponseValue;
32398 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32400 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
32401 if(!isWasmInitialized) {
32402 throw new Error("initializeWasm() must be awaited first!");
32404 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
32405 // debug statements here
32407 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
32409 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
32410 if(!isWasmInitialized) {
32411 throw new Error("initializeWasm() must be awaited first!");
32413 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
32414 return nativeResponseValue;
32416 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
32418 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
32419 if(!isWasmInitialized) {
32420 throw new Error("initializeWasm() must be awaited first!");
32422 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
32423 // debug statements here
32425 // struct LDKECDSASignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
32427 export function ClosingSigned_get_signature(this_ptr: bigint): number {
32428 if(!isWasmInitialized) {
32429 throw new Error("initializeWasm() must be awaited first!");
32431 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
32432 return nativeResponseValue;
32434 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
32436 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
32437 if(!isWasmInitialized) {
32438 throw new Error("initializeWasm() must be awaited first!");
32440 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
32441 // debug statements here
32443 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
32445 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
32446 if(!isWasmInitialized) {
32447 throw new Error("initializeWasm() must be awaited first!");
32449 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
32450 return nativeResponseValue;
32452 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
32454 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
32455 if(!isWasmInitialized) {
32456 throw new Error("initializeWasm() must be awaited first!");
32458 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
32459 // debug statements here
32461 // MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKECDSASignature signature_arg, struct LDKClosingSignedFeeRange fee_range_arg);
32463 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
32464 if(!isWasmInitialized) {
32465 throw new Error("initializeWasm() must be awaited first!");
32467 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
32468 return nativeResponseValue;
32470 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
32472 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
32473 if(!isWasmInitialized) {
32474 throw new Error("initializeWasm() must be awaited first!");
32476 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
32477 return nativeResponseValue;
32479 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
32481 export function ClosingSigned_clone(orig: bigint): bigint {
32482 if(!isWasmInitialized) {
32483 throw new Error("initializeWasm() must be awaited first!");
32485 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
32486 return nativeResponseValue;
32488 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
32490 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
32491 if(!isWasmInitialized) {
32492 throw new Error("initializeWasm() must be awaited first!");
32494 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
32495 return nativeResponseValue;
32497 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
32499 export function UpdateAddHTLC_free(this_obj: bigint): void {
32500 if(!isWasmInitialized) {
32501 throw new Error("initializeWasm() must be awaited first!");
32503 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
32504 // debug statements here
32506 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
32508 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
32509 if(!isWasmInitialized) {
32510 throw new Error("initializeWasm() must be awaited first!");
32512 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
32513 return nativeResponseValue;
32515 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32517 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
32518 if(!isWasmInitialized) {
32519 throw new Error("initializeWasm() must be awaited first!");
32521 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
32522 // debug statements here
32524 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
32526 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
32527 if(!isWasmInitialized) {
32528 throw new Error("initializeWasm() must be awaited first!");
32530 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
32531 return nativeResponseValue;
32533 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
32535 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
32536 if(!isWasmInitialized) {
32537 throw new Error("initializeWasm() must be awaited first!");
32539 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
32540 // debug statements here
32542 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
32544 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
32545 if(!isWasmInitialized) {
32546 throw new Error("initializeWasm() must be awaited first!");
32548 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
32549 return nativeResponseValue;
32551 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
32553 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
32554 if(!isWasmInitialized) {
32555 throw new Error("initializeWasm() must be awaited first!");
32557 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
32558 // debug statements here
32560 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
32562 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
32563 if(!isWasmInitialized) {
32564 throw new Error("initializeWasm() must be awaited first!");
32566 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
32567 return nativeResponseValue;
32569 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32571 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
32572 if(!isWasmInitialized) {
32573 throw new Error("initializeWasm() must be awaited first!");
32575 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
32576 // debug statements here
32578 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
32580 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
32581 if(!isWasmInitialized) {
32582 throw new Error("initializeWasm() must be awaited first!");
32584 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
32585 return nativeResponseValue;
32587 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
32589 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
32590 if(!isWasmInitialized) {
32591 throw new Error("initializeWasm() must be awaited first!");
32593 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
32594 // debug statements here
32596 // struct LDKCOption_u64Z UpdateAddHTLC_get_skimmed_fee_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
32598 export function UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: bigint): bigint {
32599 if(!isWasmInitialized) {
32600 throw new Error("initializeWasm() must be awaited first!");
32602 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_skimmed_fee_msat(this_ptr);
32603 return nativeResponseValue;
32605 // void UpdateAddHTLC_set_skimmed_fee_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
32607 export function UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
32608 if(!isWasmInitialized) {
32609 throw new Error("initializeWasm() must be awaited first!");
32611 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_skimmed_fee_msat(this_ptr, val);
32612 // debug statements here
32614 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
32616 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
32617 if(!isWasmInitialized) {
32618 throw new Error("initializeWasm() must be awaited first!");
32620 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
32621 return nativeResponseValue;
32623 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
32625 export function UpdateAddHTLC_clone(orig: bigint): bigint {
32626 if(!isWasmInitialized) {
32627 throw new Error("initializeWasm() must be awaited first!");
32629 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
32630 return nativeResponseValue;
32632 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
32634 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
32635 if(!isWasmInitialized) {
32636 throw new Error("initializeWasm() must be awaited first!");
32638 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
32639 return nativeResponseValue;
32641 // void OnionMessage_free(struct LDKOnionMessage this_obj);
32643 export function OnionMessage_free(this_obj: bigint): void {
32644 if(!isWasmInitialized) {
32645 throw new Error("initializeWasm() must be awaited first!");
32647 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
32648 // debug statements here
32650 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
32652 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
32653 if(!isWasmInitialized) {
32654 throw new Error("initializeWasm() must be awaited first!");
32656 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
32657 return nativeResponseValue;
32659 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32661 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
32662 if(!isWasmInitialized) {
32663 throw new Error("initializeWasm() must be awaited first!");
32665 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
32666 // debug statements here
32668 // struct LDKPacket OnionMessage_get_onion_routing_packet(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
32670 export function OnionMessage_get_onion_routing_packet(this_ptr: bigint): bigint {
32671 if(!isWasmInitialized) {
32672 throw new Error("initializeWasm() must be awaited first!");
32674 const nativeResponseValue = wasm.TS_OnionMessage_get_onion_routing_packet(this_ptr);
32675 return nativeResponseValue;
32677 // void OnionMessage_set_onion_routing_packet(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPacket val);
32679 export function OnionMessage_set_onion_routing_packet(this_ptr: bigint, val: bigint): void {
32680 if(!isWasmInitialized) {
32681 throw new Error("initializeWasm() must be awaited first!");
32683 const nativeResponseValue = wasm.TS_OnionMessage_set_onion_routing_packet(this_ptr, val);
32684 // debug statements here
32686 // MUST_USE_RES struct LDKOnionMessage OnionMessage_new(struct LDKPublicKey blinding_point_arg, struct LDKPacket onion_routing_packet_arg);
32688 export function OnionMessage_new(blinding_point_arg: number, onion_routing_packet_arg: bigint): bigint {
32689 if(!isWasmInitialized) {
32690 throw new Error("initializeWasm() must be awaited first!");
32692 const nativeResponseValue = wasm.TS_OnionMessage_new(blinding_point_arg, onion_routing_packet_arg);
32693 return nativeResponseValue;
32695 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
32697 export function OnionMessage_clone_ptr(arg: bigint): bigint {
32698 if(!isWasmInitialized) {
32699 throw new Error("initializeWasm() must be awaited first!");
32701 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
32702 return nativeResponseValue;
32704 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
32706 export function OnionMessage_clone(orig: bigint): bigint {
32707 if(!isWasmInitialized) {
32708 throw new Error("initializeWasm() must be awaited first!");
32710 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
32711 return nativeResponseValue;
32713 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
32715 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
32716 if(!isWasmInitialized) {
32717 throw new Error("initializeWasm() must be awaited first!");
32719 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
32720 return nativeResponseValue;
32722 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
32724 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
32725 if(!isWasmInitialized) {
32726 throw new Error("initializeWasm() must be awaited first!");
32728 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
32729 // debug statements here
32731 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
32733 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
32734 if(!isWasmInitialized) {
32735 throw new Error("initializeWasm() must be awaited first!");
32737 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
32738 return nativeResponseValue;
32740 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32742 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
32743 if(!isWasmInitialized) {
32744 throw new Error("initializeWasm() must be awaited first!");
32746 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
32747 // debug statements here
32749 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
32751 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
32752 if(!isWasmInitialized) {
32753 throw new Error("initializeWasm() must be awaited first!");
32755 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
32756 return nativeResponseValue;
32758 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
32760 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
32761 if(!isWasmInitialized) {
32762 throw new Error("initializeWasm() must be awaited first!");
32764 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
32765 // debug statements here
32767 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
32769 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
32770 if(!isWasmInitialized) {
32771 throw new Error("initializeWasm() must be awaited first!");
32773 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
32774 return nativeResponseValue;
32776 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32778 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
32779 if(!isWasmInitialized) {
32780 throw new Error("initializeWasm() must be awaited first!");
32782 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
32783 // debug statements here
32785 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
32787 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
32788 if(!isWasmInitialized) {
32789 throw new Error("initializeWasm() must be awaited first!");
32791 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
32792 return nativeResponseValue;
32794 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
32796 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
32797 if(!isWasmInitialized) {
32798 throw new Error("initializeWasm() must be awaited first!");
32800 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
32801 return nativeResponseValue;
32803 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
32805 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
32806 if(!isWasmInitialized) {
32807 throw new Error("initializeWasm() must be awaited first!");
32809 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
32810 return nativeResponseValue;
32812 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
32814 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
32815 if(!isWasmInitialized) {
32816 throw new Error("initializeWasm() must be awaited first!");
32818 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
32819 return nativeResponseValue;
32821 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
32823 export function UpdateFailHTLC_free(this_obj: bigint): void {
32824 if(!isWasmInitialized) {
32825 throw new Error("initializeWasm() must be awaited first!");
32827 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
32828 // debug statements here
32830 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
32832 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
32833 if(!isWasmInitialized) {
32834 throw new Error("initializeWasm() must be awaited first!");
32836 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
32837 return nativeResponseValue;
32839 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32841 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
32842 if(!isWasmInitialized) {
32843 throw new Error("initializeWasm() must be awaited first!");
32845 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
32846 // debug statements here
32848 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
32850 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
32851 if(!isWasmInitialized) {
32852 throw new Error("initializeWasm() must be awaited first!");
32854 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
32855 return nativeResponseValue;
32857 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
32859 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
32860 if(!isWasmInitialized) {
32861 throw new Error("initializeWasm() must be awaited first!");
32863 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
32864 // debug statements here
32866 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
32868 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
32869 if(!isWasmInitialized) {
32870 throw new Error("initializeWasm() must be awaited first!");
32872 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
32873 return nativeResponseValue;
32875 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
32877 export function UpdateFailHTLC_clone(orig: bigint): bigint {
32878 if(!isWasmInitialized) {
32879 throw new Error("initializeWasm() must be awaited first!");
32881 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
32882 return nativeResponseValue;
32884 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
32886 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
32887 if(!isWasmInitialized) {
32888 throw new Error("initializeWasm() must be awaited first!");
32890 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
32891 return nativeResponseValue;
32893 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
32895 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
32896 if(!isWasmInitialized) {
32897 throw new Error("initializeWasm() must be awaited first!");
32899 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
32900 // debug statements here
32902 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
32904 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
32905 if(!isWasmInitialized) {
32906 throw new Error("initializeWasm() must be awaited first!");
32908 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
32909 return nativeResponseValue;
32911 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32913 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
32914 if(!isWasmInitialized) {
32915 throw new Error("initializeWasm() must be awaited first!");
32917 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
32918 // debug statements here
32920 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
32922 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
32923 if(!isWasmInitialized) {
32924 throw new Error("initializeWasm() must be awaited first!");
32926 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
32927 return nativeResponseValue;
32929 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
32931 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
32932 if(!isWasmInitialized) {
32933 throw new Error("initializeWasm() must be awaited first!");
32935 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
32936 // debug statements here
32938 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
32940 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
32941 if(!isWasmInitialized) {
32942 throw new Error("initializeWasm() must be awaited first!");
32944 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
32945 return nativeResponseValue;
32947 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
32949 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
32950 if(!isWasmInitialized) {
32951 throw new Error("initializeWasm() must be awaited first!");
32953 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
32954 // debug statements here
32956 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
32958 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
32959 if(!isWasmInitialized) {
32960 throw new Error("initializeWasm() must be awaited first!");
32962 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
32963 return nativeResponseValue;
32965 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
32967 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
32968 if(!isWasmInitialized) {
32969 throw new Error("initializeWasm() must be awaited first!");
32971 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
32972 return nativeResponseValue;
32974 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
32976 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
32977 if(!isWasmInitialized) {
32978 throw new Error("initializeWasm() must be awaited first!");
32980 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
32981 return nativeResponseValue;
32983 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
32985 export function CommitmentSigned_free(this_obj: bigint): void {
32986 if(!isWasmInitialized) {
32987 throw new Error("initializeWasm() must be awaited first!");
32989 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
32990 // debug statements here
32992 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
32994 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
32995 if(!isWasmInitialized) {
32996 throw new Error("initializeWasm() must be awaited first!");
32998 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
32999 return nativeResponseValue;
33001 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33003 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
33004 if(!isWasmInitialized) {
33005 throw new Error("initializeWasm() must be awaited first!");
33007 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
33008 // debug statements here
33010 // struct LDKECDSASignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
33012 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
33013 if(!isWasmInitialized) {
33014 throw new Error("initializeWasm() must be awaited first!");
33016 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
33017 return nativeResponseValue;
33019 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
33021 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
33022 if(!isWasmInitialized) {
33023 throw new Error("initializeWasm() must be awaited first!");
33025 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
33026 // debug statements here
33028 // struct LDKCVec_ECDSASignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
33030 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
33031 if(!isWasmInitialized) {
33032 throw new Error("initializeWasm() must be awaited first!");
33034 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
33035 return nativeResponseValue;
33037 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
33039 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
33040 if(!isWasmInitialized) {
33041 throw new Error("initializeWasm() must be awaited first!");
33043 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
33044 // debug statements here
33046 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKECDSASignature signature_arg, struct LDKCVec_ECDSASignatureZ htlc_signatures_arg);
33048 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
33049 if(!isWasmInitialized) {
33050 throw new Error("initializeWasm() must be awaited first!");
33052 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
33053 return nativeResponseValue;
33055 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
33057 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
33058 if(!isWasmInitialized) {
33059 throw new Error("initializeWasm() must be awaited first!");
33061 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
33062 return nativeResponseValue;
33064 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
33066 export function CommitmentSigned_clone(orig: bigint): bigint {
33067 if(!isWasmInitialized) {
33068 throw new Error("initializeWasm() must be awaited first!");
33070 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
33071 return nativeResponseValue;
33073 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
33075 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
33076 if(!isWasmInitialized) {
33077 throw new Error("initializeWasm() must be awaited first!");
33079 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
33080 return nativeResponseValue;
33082 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
33084 export function RevokeAndACK_free(this_obj: bigint): void {
33085 if(!isWasmInitialized) {
33086 throw new Error("initializeWasm() must be awaited first!");
33088 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
33089 // debug statements here
33091 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
33093 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
33094 if(!isWasmInitialized) {
33095 throw new Error("initializeWasm() must be awaited first!");
33097 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
33098 return nativeResponseValue;
33100 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33102 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
33103 if(!isWasmInitialized) {
33104 throw new Error("initializeWasm() must be awaited first!");
33106 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
33107 // debug statements here
33109 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
33111 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
33112 if(!isWasmInitialized) {
33113 throw new Error("initializeWasm() must be awaited first!");
33115 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
33116 return nativeResponseValue;
33118 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33120 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
33121 if(!isWasmInitialized) {
33122 throw new Error("initializeWasm() must be awaited first!");
33124 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
33125 // debug statements here
33127 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
33129 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
33130 if(!isWasmInitialized) {
33131 throw new Error("initializeWasm() must be awaited first!");
33133 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
33134 return nativeResponseValue;
33136 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33138 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
33139 if(!isWasmInitialized) {
33140 throw new Error("initializeWasm() must be awaited first!");
33142 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
33143 // debug statements here
33145 // 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);
33147 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
33148 if(!isWasmInitialized) {
33149 throw new Error("initializeWasm() must be awaited first!");
33151 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
33152 return nativeResponseValue;
33154 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
33156 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
33157 if(!isWasmInitialized) {
33158 throw new Error("initializeWasm() must be awaited first!");
33160 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
33161 return nativeResponseValue;
33163 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
33165 export function RevokeAndACK_clone(orig: bigint): bigint {
33166 if(!isWasmInitialized) {
33167 throw new Error("initializeWasm() must be awaited first!");
33169 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
33170 return nativeResponseValue;
33172 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
33174 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
33175 if(!isWasmInitialized) {
33176 throw new Error("initializeWasm() must be awaited first!");
33178 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
33179 return nativeResponseValue;
33181 // void UpdateFee_free(struct LDKUpdateFee this_obj);
33183 export function UpdateFee_free(this_obj: bigint): void {
33184 if(!isWasmInitialized) {
33185 throw new Error("initializeWasm() must be awaited first!");
33187 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
33188 // debug statements here
33190 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
33192 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
33193 if(!isWasmInitialized) {
33194 throw new Error("initializeWasm() must be awaited first!");
33196 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
33197 return nativeResponseValue;
33199 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33201 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
33202 if(!isWasmInitialized) {
33203 throw new Error("initializeWasm() must be awaited first!");
33205 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
33206 // debug statements here
33208 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
33210 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
33211 if(!isWasmInitialized) {
33212 throw new Error("initializeWasm() must be awaited first!");
33214 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
33215 return nativeResponseValue;
33217 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
33219 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
33220 if(!isWasmInitialized) {
33221 throw new Error("initializeWasm() must be awaited first!");
33223 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
33224 // debug statements here
33226 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
33228 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
33229 if(!isWasmInitialized) {
33230 throw new Error("initializeWasm() must be awaited first!");
33232 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
33233 return nativeResponseValue;
33235 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
33237 export function UpdateFee_clone_ptr(arg: bigint): bigint {
33238 if(!isWasmInitialized) {
33239 throw new Error("initializeWasm() must be awaited first!");
33241 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
33242 return nativeResponseValue;
33244 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
33246 export function UpdateFee_clone(orig: bigint): bigint {
33247 if(!isWasmInitialized) {
33248 throw new Error("initializeWasm() must be awaited first!");
33250 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
33251 return nativeResponseValue;
33253 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
33255 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
33256 if(!isWasmInitialized) {
33257 throw new Error("initializeWasm() must be awaited first!");
33259 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
33260 return nativeResponseValue;
33262 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
33264 export function ChannelReestablish_free(this_obj: bigint): void {
33265 if(!isWasmInitialized) {
33266 throw new Error("initializeWasm() must be awaited first!");
33268 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
33269 // debug statements here
33271 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
33273 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
33274 if(!isWasmInitialized) {
33275 throw new Error("initializeWasm() must be awaited first!");
33277 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
33278 return nativeResponseValue;
33280 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33282 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
33283 if(!isWasmInitialized) {
33284 throw new Error("initializeWasm() must be awaited first!");
33286 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
33287 // debug statements here
33289 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33291 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
33292 if(!isWasmInitialized) {
33293 throw new Error("initializeWasm() must be awaited first!");
33295 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
33296 return nativeResponseValue;
33298 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
33300 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
33301 if(!isWasmInitialized) {
33302 throw new Error("initializeWasm() must be awaited first!");
33304 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
33305 // debug statements here
33307 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33309 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
33310 if(!isWasmInitialized) {
33311 throw new Error("initializeWasm() must be awaited first!");
33313 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
33314 return nativeResponseValue;
33316 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
33318 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
33319 if(!isWasmInitialized) {
33320 throw new Error("initializeWasm() must be awaited first!");
33322 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
33323 // debug statements here
33325 // const uint8_t (*ChannelReestablish_get_your_last_per_commitment_secret(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
33327 export function ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: bigint): number {
33328 if(!isWasmInitialized) {
33329 throw new Error("initializeWasm() must be awaited first!");
33331 const nativeResponseValue = wasm.TS_ChannelReestablish_get_your_last_per_commitment_secret(this_ptr);
33332 return nativeResponseValue;
33334 // void ChannelReestablish_set_your_last_per_commitment_secret(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33336 export function ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
33337 if(!isWasmInitialized) {
33338 throw new Error("initializeWasm() must be awaited first!");
33340 const nativeResponseValue = wasm.TS_ChannelReestablish_set_your_last_per_commitment_secret(this_ptr, val);
33341 // debug statements here
33343 // struct LDKPublicKey ChannelReestablish_get_my_current_per_commitment_point(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33345 export function ChannelReestablish_get_my_current_per_commitment_point(this_ptr: bigint): number {
33346 if(!isWasmInitialized) {
33347 throw new Error("initializeWasm() must be awaited first!");
33349 const nativeResponseValue = wasm.TS_ChannelReestablish_get_my_current_per_commitment_point(this_ptr);
33350 return nativeResponseValue;
33352 // void ChannelReestablish_set_my_current_per_commitment_point(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33354 export function ChannelReestablish_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
33355 if(!isWasmInitialized) {
33356 throw new Error("initializeWasm() must be awaited first!");
33358 const nativeResponseValue = wasm.TS_ChannelReestablish_set_my_current_per_commitment_point(this_ptr, val);
33359 // debug statements here
33361 // struct LDKCOption_ThirtyTwoBytesZ ChannelReestablish_get_next_funding_txid(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33363 export function ChannelReestablish_get_next_funding_txid(this_ptr: bigint): bigint {
33364 if(!isWasmInitialized) {
33365 throw new Error("initializeWasm() must be awaited first!");
33367 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_funding_txid(this_ptr);
33368 return nativeResponseValue;
33370 // void ChannelReestablish_set_next_funding_txid(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
33372 export function ChannelReestablish_set_next_funding_txid(this_ptr: bigint, val: bigint): void {
33373 if(!isWasmInitialized) {
33374 throw new Error("initializeWasm() must be awaited first!");
33376 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_funding_txid(this_ptr, val);
33377 // debug statements here
33379 // 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_ThirtyTwoBytesZ next_funding_txid_arg);
33381 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 {
33382 if(!isWasmInitialized) {
33383 throw new Error("initializeWasm() must be awaited first!");
33385 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);
33386 return nativeResponseValue;
33388 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
33390 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
33391 if(!isWasmInitialized) {
33392 throw new Error("initializeWasm() must be awaited first!");
33394 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
33395 return nativeResponseValue;
33397 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
33399 export function ChannelReestablish_clone(orig: bigint): bigint {
33400 if(!isWasmInitialized) {
33401 throw new Error("initializeWasm() must be awaited first!");
33403 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
33404 return nativeResponseValue;
33406 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
33408 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
33409 if(!isWasmInitialized) {
33410 throw new Error("initializeWasm() must be awaited first!");
33412 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
33413 return nativeResponseValue;
33415 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
33417 export function AnnouncementSignatures_free(this_obj: bigint): void {
33418 if(!isWasmInitialized) {
33419 throw new Error("initializeWasm() must be awaited first!");
33421 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
33422 // debug statements here
33424 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
33426 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
33427 if(!isWasmInitialized) {
33428 throw new Error("initializeWasm() must be awaited first!");
33430 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
33431 return nativeResponseValue;
33433 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33435 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
33436 if(!isWasmInitialized) {
33437 throw new Error("initializeWasm() must be awaited first!");
33439 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
33440 // debug statements here
33442 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
33444 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
33445 if(!isWasmInitialized) {
33446 throw new Error("initializeWasm() must be awaited first!");
33448 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
33449 return nativeResponseValue;
33451 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
33453 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
33454 if(!isWasmInitialized) {
33455 throw new Error("initializeWasm() must be awaited first!");
33457 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
33458 // debug statements here
33460 // struct LDKECDSASignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
33462 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
33463 if(!isWasmInitialized) {
33464 throw new Error("initializeWasm() must be awaited first!");
33466 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
33467 return nativeResponseValue;
33469 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
33471 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
33472 if(!isWasmInitialized) {
33473 throw new Error("initializeWasm() must be awaited first!");
33475 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
33476 // debug statements here
33478 // struct LDKECDSASignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
33480 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
33481 if(!isWasmInitialized) {
33482 throw new Error("initializeWasm() must be awaited first!");
33484 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
33485 return nativeResponseValue;
33487 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
33489 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
33490 if(!isWasmInitialized) {
33491 throw new Error("initializeWasm() must be awaited first!");
33493 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
33494 // debug statements here
33496 // MUST_USE_RES struct LDKAnnouncementSignatures AnnouncementSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t short_channel_id_arg, struct LDKECDSASignature node_signature_arg, struct LDKECDSASignature bitcoin_signature_arg);
33498 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
33499 if(!isWasmInitialized) {
33500 throw new Error("initializeWasm() must be awaited first!");
33502 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
33503 return nativeResponseValue;
33505 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
33507 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
33508 if(!isWasmInitialized) {
33509 throw new Error("initializeWasm() must be awaited first!");
33511 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
33512 return nativeResponseValue;
33514 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
33516 export function AnnouncementSignatures_clone(orig: bigint): bigint {
33517 if(!isWasmInitialized) {
33518 throw new Error("initializeWasm() must be awaited first!");
33520 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
33521 return nativeResponseValue;
33523 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
33525 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
33526 if(!isWasmInitialized) {
33527 throw new Error("initializeWasm() must be awaited first!");
33529 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
33530 return nativeResponseValue;
33532 // void SocketAddress_free(struct LDKSocketAddress this_ptr);
33534 export function SocketAddress_free(this_ptr: bigint): void {
33535 if(!isWasmInitialized) {
33536 throw new Error("initializeWasm() must be awaited first!");
33538 const nativeResponseValue = wasm.TS_SocketAddress_free(this_ptr);
33539 // debug statements here
33541 // uint64_t SocketAddress_clone_ptr(LDKSocketAddress *NONNULL_PTR arg);
33543 export function SocketAddress_clone_ptr(arg: bigint): bigint {
33544 if(!isWasmInitialized) {
33545 throw new Error("initializeWasm() must be awaited first!");
33547 const nativeResponseValue = wasm.TS_SocketAddress_clone_ptr(arg);
33548 return nativeResponseValue;
33550 // struct LDKSocketAddress SocketAddress_clone(const struct LDKSocketAddress *NONNULL_PTR orig);
33552 export function SocketAddress_clone(orig: bigint): bigint {
33553 if(!isWasmInitialized) {
33554 throw new Error("initializeWasm() must be awaited first!");
33556 const nativeResponseValue = wasm.TS_SocketAddress_clone(orig);
33557 return nativeResponseValue;
33559 // struct LDKSocketAddress SocketAddress_tcp_ip_v4(struct LDKFourBytes addr, uint16_t port);
33561 export function SocketAddress_tcp_ip_v4(addr: number, port: number): bigint {
33562 if(!isWasmInitialized) {
33563 throw new Error("initializeWasm() must be awaited first!");
33565 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v4(addr, port);
33566 return nativeResponseValue;
33568 // struct LDKSocketAddress SocketAddress_tcp_ip_v6(struct LDKSixteenBytes addr, uint16_t port);
33570 export function SocketAddress_tcp_ip_v6(addr: number, port: number): bigint {
33571 if(!isWasmInitialized) {
33572 throw new Error("initializeWasm() must be awaited first!");
33574 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v6(addr, port);
33575 return nativeResponseValue;
33577 // struct LDKSocketAddress SocketAddress_onion_v2(struct LDKTwelveBytes a);
33579 export function SocketAddress_onion_v2(a: number): bigint {
33580 if(!isWasmInitialized) {
33581 throw new Error("initializeWasm() must be awaited first!");
33583 const nativeResponseValue = wasm.TS_SocketAddress_onion_v2(a);
33584 return nativeResponseValue;
33586 // struct LDKSocketAddress SocketAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
33588 export function SocketAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
33589 if(!isWasmInitialized) {
33590 throw new Error("initializeWasm() must be awaited first!");
33592 const nativeResponseValue = wasm.TS_SocketAddress_onion_v3(ed25519_pubkey, checksum, version, port);
33593 return nativeResponseValue;
33595 // struct LDKSocketAddress SocketAddress_hostname(struct LDKHostname hostname, uint16_t port);
33597 export function SocketAddress_hostname(hostname: bigint, port: number): bigint {
33598 if(!isWasmInitialized) {
33599 throw new Error("initializeWasm() must be awaited first!");
33601 const nativeResponseValue = wasm.TS_SocketAddress_hostname(hostname, port);
33602 return nativeResponseValue;
33604 // bool SocketAddress_eq(const struct LDKSocketAddress *NONNULL_PTR a, const struct LDKSocketAddress *NONNULL_PTR b);
33606 export function SocketAddress_eq(a: bigint, b: bigint): boolean {
33607 if(!isWasmInitialized) {
33608 throw new Error("initializeWasm() must be awaited first!");
33610 const nativeResponseValue = wasm.TS_SocketAddress_eq(a, b);
33611 return nativeResponseValue;
33613 // struct LDKCVec_u8Z SocketAddress_write(const struct LDKSocketAddress *NONNULL_PTR obj);
33615 export function SocketAddress_write(obj: bigint): number {
33616 if(!isWasmInitialized) {
33617 throw new Error("initializeWasm() must be awaited first!");
33619 const nativeResponseValue = wasm.TS_SocketAddress_write(obj);
33620 return nativeResponseValue;
33622 // struct LDKCResult_SocketAddressDecodeErrorZ SocketAddress_read(struct LDKu8slice ser);
33624 export function SocketAddress_read(ser: number): bigint {
33625 if(!isWasmInitialized) {
33626 throw new Error("initializeWasm() must be awaited first!");
33628 const nativeResponseValue = wasm.TS_SocketAddress_read(ser);
33629 return nativeResponseValue;
33631 // enum LDKSocketAddressParseError SocketAddressParseError_clone(const enum LDKSocketAddressParseError *NONNULL_PTR orig);
33633 export function SocketAddressParseError_clone(orig: bigint): SocketAddressParseError {
33634 if(!isWasmInitialized) {
33635 throw new Error("initializeWasm() must be awaited first!");
33637 const nativeResponseValue = wasm.TS_SocketAddressParseError_clone(orig);
33638 return nativeResponseValue;
33640 // enum LDKSocketAddressParseError SocketAddressParseError_socket_addr_parse(void);
33642 export function SocketAddressParseError_socket_addr_parse(): SocketAddressParseError {
33643 if(!isWasmInitialized) {
33644 throw new Error("initializeWasm() must be awaited first!");
33646 const nativeResponseValue = wasm.TS_SocketAddressParseError_socket_addr_parse();
33647 return nativeResponseValue;
33649 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_input(void);
33651 export function SocketAddressParseError_invalid_input(): SocketAddressParseError {
33652 if(!isWasmInitialized) {
33653 throw new Error("initializeWasm() must be awaited first!");
33655 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_input();
33656 return nativeResponseValue;
33658 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_port(void);
33660 export function SocketAddressParseError_invalid_port(): SocketAddressParseError {
33661 if(!isWasmInitialized) {
33662 throw new Error("initializeWasm() must be awaited first!");
33664 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_port();
33665 return nativeResponseValue;
33667 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_onion_v3(void);
33669 export function SocketAddressParseError_invalid_onion_v3(): SocketAddressParseError {
33670 if(!isWasmInitialized) {
33671 throw new Error("initializeWasm() must be awaited first!");
33673 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_onion_v3();
33674 return nativeResponseValue;
33676 // bool SocketAddressParseError_eq(const enum LDKSocketAddressParseError *NONNULL_PTR a, const enum LDKSocketAddressParseError *NONNULL_PTR b);
33678 export function SocketAddressParseError_eq(a: bigint, b: bigint): boolean {
33679 if(!isWasmInitialized) {
33680 throw new Error("initializeWasm() must be awaited first!");
33682 const nativeResponseValue = wasm.TS_SocketAddressParseError_eq(a, b);
33683 return nativeResponseValue;
33685 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ parse_onion_address(struct LDKStr host, uint16_t port);
33687 export function parse_onion_address(host: number, port: number): bigint {
33688 if(!isWasmInitialized) {
33689 throw new Error("initializeWasm() must be awaited first!");
33691 const nativeResponseValue = wasm.TS_parse_onion_address(host, port);
33692 return nativeResponseValue;
33694 // void UnsignedGossipMessage_free(struct LDKUnsignedGossipMessage this_ptr);
33696 export function UnsignedGossipMessage_free(this_ptr: bigint): void {
33697 if(!isWasmInitialized) {
33698 throw new Error("initializeWasm() must be awaited first!");
33700 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_free(this_ptr);
33701 // debug statements here
33703 // uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg);
33705 export function UnsignedGossipMessage_clone_ptr(arg: bigint): bigint {
33706 if(!isWasmInitialized) {
33707 throw new Error("initializeWasm() must be awaited first!");
33709 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone_ptr(arg);
33710 return nativeResponseValue;
33712 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_clone(const struct LDKUnsignedGossipMessage *NONNULL_PTR orig);
33714 export function UnsignedGossipMessage_clone(orig: bigint): bigint {
33715 if(!isWasmInitialized) {
33716 throw new Error("initializeWasm() must be awaited first!");
33718 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone(orig);
33719 return nativeResponseValue;
33721 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_announcement(struct LDKUnsignedChannelAnnouncement a);
33723 export function UnsignedGossipMessage_channel_announcement(a: bigint): bigint {
33724 if(!isWasmInitialized) {
33725 throw new Error("initializeWasm() must be awaited first!");
33727 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_announcement(a);
33728 return nativeResponseValue;
33730 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_update(struct LDKUnsignedChannelUpdate a);
33732 export function UnsignedGossipMessage_channel_update(a: bigint): bigint {
33733 if(!isWasmInitialized) {
33734 throw new Error("initializeWasm() must be awaited first!");
33736 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_update(a);
33737 return nativeResponseValue;
33739 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_node_announcement(struct LDKUnsignedNodeAnnouncement a);
33741 export function UnsignedGossipMessage_node_announcement(a: bigint): bigint {
33742 if(!isWasmInitialized) {
33743 throw new Error("initializeWasm() must be awaited first!");
33745 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_node_announcement(a);
33746 return nativeResponseValue;
33748 // struct LDKCVec_u8Z UnsignedGossipMessage_write(const struct LDKUnsignedGossipMessage *NONNULL_PTR obj);
33750 export function UnsignedGossipMessage_write(obj: bigint): number {
33751 if(!isWasmInitialized) {
33752 throw new Error("initializeWasm() must be awaited first!");
33754 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_write(obj);
33755 return nativeResponseValue;
33757 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
33759 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
33760 if(!isWasmInitialized) {
33761 throw new Error("initializeWasm() must be awaited first!");
33763 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
33764 // debug statements here
33766 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
33768 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
33769 if(!isWasmInitialized) {
33770 throw new Error("initializeWasm() must be awaited first!");
33772 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
33773 return nativeResponseValue;
33775 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
33777 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
33778 if(!isWasmInitialized) {
33779 throw new Error("initializeWasm() must be awaited first!");
33781 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
33782 // debug statements here
33784 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
33786 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
33787 if(!isWasmInitialized) {
33788 throw new Error("initializeWasm() must be awaited first!");
33790 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
33791 return nativeResponseValue;
33793 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
33795 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
33796 if(!isWasmInitialized) {
33797 throw new Error("initializeWasm() must be awaited first!");
33799 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
33800 // debug statements here
33802 // struct LDKNodeId UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
33804 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): bigint {
33805 if(!isWasmInitialized) {
33806 throw new Error("initializeWasm() must be awaited first!");
33808 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
33809 return nativeResponseValue;
33811 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
33813 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: bigint): void {
33814 if(!isWasmInitialized) {
33815 throw new Error("initializeWasm() must be awaited first!");
33817 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
33818 // debug statements here
33820 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
33822 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
33823 if(!isWasmInitialized) {
33824 throw new Error("initializeWasm() must be awaited first!");
33826 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
33827 return nativeResponseValue;
33829 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
33831 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
33832 if(!isWasmInitialized) {
33833 throw new Error("initializeWasm() must be awaited first!");
33835 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
33836 // debug statements here
33838 // struct LDKNodeAlias UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
33840 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): bigint {
33841 if(!isWasmInitialized) {
33842 throw new Error("initializeWasm() must be awaited first!");
33844 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
33845 return nativeResponseValue;
33847 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
33849 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: bigint): void {
33850 if(!isWasmInitialized) {
33851 throw new Error("initializeWasm() must be awaited first!");
33853 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
33854 // debug statements here
33856 // struct LDKCVec_SocketAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
33858 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
33859 if(!isWasmInitialized) {
33860 throw new Error("initializeWasm() must be awaited first!");
33862 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
33863 return nativeResponseValue;
33865 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_SocketAddressZ val);
33867 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
33868 if(!isWasmInitialized) {
33869 throw new Error("initializeWasm() must be awaited first!");
33871 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
33872 // debug statements here
33874 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
33876 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
33877 if(!isWasmInitialized) {
33878 throw new Error("initializeWasm() must be awaited first!");
33880 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
33881 return nativeResponseValue;
33883 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
33885 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
33886 if(!isWasmInitialized) {
33887 throw new Error("initializeWasm() must be awaited first!");
33889 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
33890 return nativeResponseValue;
33892 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
33894 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
33895 if(!isWasmInitialized) {
33896 throw new Error("initializeWasm() must be awaited first!");
33898 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
33899 return nativeResponseValue;
33901 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
33903 export function NodeAnnouncement_free(this_obj: bigint): void {
33904 if(!isWasmInitialized) {
33905 throw new Error("initializeWasm() must be awaited first!");
33907 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
33908 // debug statements here
33910 // struct LDKECDSASignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
33912 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
33913 if(!isWasmInitialized) {
33914 throw new Error("initializeWasm() must be awaited first!");
33916 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
33917 return nativeResponseValue;
33919 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
33921 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
33922 if(!isWasmInitialized) {
33923 throw new Error("initializeWasm() must be awaited first!");
33925 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
33926 // debug statements here
33928 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
33930 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
33931 if(!isWasmInitialized) {
33932 throw new Error("initializeWasm() must be awaited first!");
33934 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
33935 return nativeResponseValue;
33937 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
33939 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
33940 if(!isWasmInitialized) {
33941 throw new Error("initializeWasm() must be awaited first!");
33943 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
33944 // debug statements here
33946 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
33948 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
33949 if(!isWasmInitialized) {
33950 throw new Error("initializeWasm() must be awaited first!");
33952 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
33953 return nativeResponseValue;
33955 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
33957 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
33958 if(!isWasmInitialized) {
33959 throw new Error("initializeWasm() must be awaited first!");
33961 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
33962 return nativeResponseValue;
33964 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
33966 export function NodeAnnouncement_clone(orig: bigint): bigint {
33967 if(!isWasmInitialized) {
33968 throw new Error("initializeWasm() must be awaited first!");
33970 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
33971 return nativeResponseValue;
33973 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
33975 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
33976 if(!isWasmInitialized) {
33977 throw new Error("initializeWasm() must be awaited first!");
33979 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
33980 return nativeResponseValue;
33982 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
33984 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
33985 if(!isWasmInitialized) {
33986 throw new Error("initializeWasm() must be awaited first!");
33988 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
33989 // debug statements here
33991 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
33993 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
33994 if(!isWasmInitialized) {
33995 throw new Error("initializeWasm() must be awaited first!");
33997 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
33998 return nativeResponseValue;
34000 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
34002 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
34003 if(!isWasmInitialized) {
34004 throw new Error("initializeWasm() must be awaited first!");
34006 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
34007 // debug statements here
34009 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
34011 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
34012 if(!isWasmInitialized) {
34013 throw new Error("initializeWasm() must be awaited first!");
34015 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
34016 return nativeResponseValue;
34018 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34020 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
34021 if(!isWasmInitialized) {
34022 throw new Error("initializeWasm() must be awaited first!");
34024 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
34025 // debug statements here
34027 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34029 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
34030 if(!isWasmInitialized) {
34031 throw new Error("initializeWasm() must be awaited first!");
34033 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
34034 return nativeResponseValue;
34036 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
34038 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
34039 if(!isWasmInitialized) {
34040 throw new Error("initializeWasm() must be awaited first!");
34042 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
34043 // debug statements here
34045 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34047 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): bigint {
34048 if(!isWasmInitialized) {
34049 throw new Error("initializeWasm() must be awaited first!");
34051 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
34052 return nativeResponseValue;
34054 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34056 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: bigint): void {
34057 if(!isWasmInitialized) {
34058 throw new Error("initializeWasm() must be awaited first!");
34060 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
34061 // debug statements here
34063 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34065 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): bigint {
34066 if(!isWasmInitialized) {
34067 throw new Error("initializeWasm() must be awaited first!");
34069 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
34070 return nativeResponseValue;
34072 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34074 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: bigint): void {
34075 if(!isWasmInitialized) {
34076 throw new Error("initializeWasm() must be awaited first!");
34078 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
34079 // debug statements here
34081 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34083 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): bigint {
34084 if(!isWasmInitialized) {
34085 throw new Error("initializeWasm() must be awaited first!");
34087 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
34088 return nativeResponseValue;
34090 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34092 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: bigint): void {
34093 if(!isWasmInitialized) {
34094 throw new Error("initializeWasm() must be awaited first!");
34096 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
34097 // debug statements here
34099 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34101 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): bigint {
34102 if(!isWasmInitialized) {
34103 throw new Error("initializeWasm() must be awaited first!");
34105 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
34106 return nativeResponseValue;
34108 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34110 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: bigint): void {
34111 if(!isWasmInitialized) {
34112 throw new Error("initializeWasm() must be awaited first!");
34114 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
34115 // debug statements here
34117 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_get_excess_data(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34119 export function UnsignedChannelAnnouncement_get_excess_data(this_ptr: bigint): number {
34120 if(!isWasmInitialized) {
34121 throw new Error("initializeWasm() must be awaited first!");
34123 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_excess_data(this_ptr);
34124 return nativeResponseValue;
34126 // void UnsignedChannelAnnouncement_set_excess_data(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
34128 export function UnsignedChannelAnnouncement_set_excess_data(this_ptr: bigint, val: number): void {
34129 if(!isWasmInitialized) {
34130 throw new Error("initializeWasm() must be awaited first!");
34132 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_excess_data(this_ptr, val);
34133 // debug statements here
34135 // MUST_USE_RES struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_new(struct LDKChannelFeatures features_arg, struct LDKThirtyTwoBytes chain_hash_arg, uint64_t short_channel_id_arg, struct LDKNodeId node_id_1_arg, struct LDKNodeId node_id_2_arg, struct LDKNodeId bitcoin_key_1_arg, struct LDKNodeId bitcoin_key_2_arg, struct LDKCVec_u8Z excess_data_arg);
34137 export function UnsignedChannelAnnouncement_new(features_arg: bigint, chain_hash_arg: number, short_channel_id_arg: bigint, node_id_1_arg: bigint, node_id_2_arg: bigint, bitcoin_key_1_arg: bigint, bitcoin_key_2_arg: bigint, excess_data_arg: number): bigint {
34138 if(!isWasmInitialized) {
34139 throw new Error("initializeWasm() must be awaited first!");
34141 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_new(features_arg, chain_hash_arg, short_channel_id_arg, node_id_1_arg, node_id_2_arg, bitcoin_key_1_arg, bitcoin_key_2_arg, excess_data_arg);
34142 return nativeResponseValue;
34144 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
34146 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
34147 if(!isWasmInitialized) {
34148 throw new Error("initializeWasm() must be awaited first!");
34150 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
34151 return nativeResponseValue;
34153 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
34155 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
34156 if(!isWasmInitialized) {
34157 throw new Error("initializeWasm() must be awaited first!");
34159 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
34160 return nativeResponseValue;
34162 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
34164 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
34165 if(!isWasmInitialized) {
34166 throw new Error("initializeWasm() must be awaited first!");
34168 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
34169 return nativeResponseValue;
34171 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
34173 export function ChannelAnnouncement_free(this_obj: bigint): void {
34174 if(!isWasmInitialized) {
34175 throw new Error("initializeWasm() must be awaited first!");
34177 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
34178 // debug statements here
34180 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34182 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
34183 if(!isWasmInitialized) {
34184 throw new Error("initializeWasm() must be awaited first!");
34186 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
34187 return nativeResponseValue;
34189 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34191 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
34192 if(!isWasmInitialized) {
34193 throw new Error("initializeWasm() must be awaited first!");
34195 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
34196 // debug statements here
34198 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34200 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
34201 if(!isWasmInitialized) {
34202 throw new Error("initializeWasm() must be awaited first!");
34204 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
34205 return nativeResponseValue;
34207 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34209 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
34210 if(!isWasmInitialized) {
34211 throw new Error("initializeWasm() must be awaited first!");
34213 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
34214 // debug statements here
34216 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34218 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
34219 if(!isWasmInitialized) {
34220 throw new Error("initializeWasm() must be awaited first!");
34222 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
34223 return nativeResponseValue;
34225 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34227 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
34228 if(!isWasmInitialized) {
34229 throw new Error("initializeWasm() must be awaited first!");
34231 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
34232 // debug statements here
34234 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34236 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
34237 if(!isWasmInitialized) {
34238 throw new Error("initializeWasm() must be awaited first!");
34240 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
34241 return nativeResponseValue;
34243 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34245 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
34246 if(!isWasmInitialized) {
34247 throw new Error("initializeWasm() must be awaited first!");
34249 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
34250 // debug statements here
34252 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34254 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
34255 if(!isWasmInitialized) {
34256 throw new Error("initializeWasm() must be awaited first!");
34258 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
34259 return nativeResponseValue;
34261 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
34263 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
34264 if(!isWasmInitialized) {
34265 throw new Error("initializeWasm() must be awaited first!");
34267 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
34268 // debug statements here
34270 // MUST_USE_RES struct LDKChannelAnnouncement ChannelAnnouncement_new(struct LDKECDSASignature node_signature_1_arg, struct LDKECDSASignature node_signature_2_arg, struct LDKECDSASignature bitcoin_signature_1_arg, struct LDKECDSASignature bitcoin_signature_2_arg, struct LDKUnsignedChannelAnnouncement contents_arg);
34272 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 {
34273 if(!isWasmInitialized) {
34274 throw new Error("initializeWasm() must be awaited first!");
34276 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
34277 return nativeResponseValue;
34279 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
34281 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
34282 if(!isWasmInitialized) {
34283 throw new Error("initializeWasm() must be awaited first!");
34285 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
34286 return nativeResponseValue;
34288 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
34290 export function ChannelAnnouncement_clone(orig: bigint): bigint {
34291 if(!isWasmInitialized) {
34292 throw new Error("initializeWasm() must be awaited first!");
34294 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
34295 return nativeResponseValue;
34297 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
34299 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
34300 if(!isWasmInitialized) {
34301 throw new Error("initializeWasm() must be awaited first!");
34303 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
34304 return nativeResponseValue;
34306 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
34308 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
34309 if(!isWasmInitialized) {
34310 throw new Error("initializeWasm() must be awaited first!");
34312 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
34313 // debug statements here
34315 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
34317 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
34318 if(!isWasmInitialized) {
34319 throw new Error("initializeWasm() must be awaited first!");
34321 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
34322 return nativeResponseValue;
34324 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34326 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
34327 if(!isWasmInitialized) {
34328 throw new Error("initializeWasm() must be awaited first!");
34330 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
34331 // debug statements here
34333 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34335 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
34336 if(!isWasmInitialized) {
34337 throw new Error("initializeWasm() must be awaited first!");
34339 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
34340 return nativeResponseValue;
34342 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
34344 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
34345 if(!isWasmInitialized) {
34346 throw new Error("initializeWasm() must be awaited first!");
34348 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
34349 // debug statements here
34351 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34353 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
34354 if(!isWasmInitialized) {
34355 throw new Error("initializeWasm() must be awaited first!");
34357 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
34358 return nativeResponseValue;
34360 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
34362 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
34363 if(!isWasmInitialized) {
34364 throw new Error("initializeWasm() must be awaited first!");
34366 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
34367 // debug statements here
34369 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34371 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
34372 if(!isWasmInitialized) {
34373 throw new Error("initializeWasm() must be awaited first!");
34375 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
34376 return nativeResponseValue;
34378 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
34380 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
34381 if(!isWasmInitialized) {
34382 throw new Error("initializeWasm() must be awaited first!");
34384 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
34385 // debug statements here
34387 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34389 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
34390 if(!isWasmInitialized) {
34391 throw new Error("initializeWasm() must be awaited first!");
34393 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
34394 return nativeResponseValue;
34396 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
34398 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
34399 if(!isWasmInitialized) {
34400 throw new Error("initializeWasm() must be awaited first!");
34402 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
34403 // debug statements here
34405 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34407 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
34408 if(!isWasmInitialized) {
34409 throw new Error("initializeWasm() must be awaited first!");
34411 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
34412 return nativeResponseValue;
34414 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
34416 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
34417 if(!isWasmInitialized) {
34418 throw new Error("initializeWasm() must be awaited first!");
34420 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
34421 // debug statements here
34423 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34425 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
34426 if(!isWasmInitialized) {
34427 throw new Error("initializeWasm() must be awaited first!");
34429 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
34430 return nativeResponseValue;
34432 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
34434 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
34435 if(!isWasmInitialized) {
34436 throw new Error("initializeWasm() must be awaited first!");
34438 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
34439 // debug statements here
34441 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34443 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
34444 if(!isWasmInitialized) {
34445 throw new Error("initializeWasm() must be awaited first!");
34447 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
34448 return nativeResponseValue;
34450 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
34452 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
34453 if(!isWasmInitialized) {
34454 throw new Error("initializeWasm() must be awaited first!");
34456 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
34457 // debug statements here
34459 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34461 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
34462 if(!isWasmInitialized) {
34463 throw new Error("initializeWasm() must be awaited first!");
34465 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
34466 return nativeResponseValue;
34468 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
34470 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
34471 if(!isWasmInitialized) {
34472 throw new Error("initializeWasm() must be awaited first!");
34474 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
34475 // debug statements here
34477 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34479 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
34480 if(!isWasmInitialized) {
34481 throw new Error("initializeWasm() must be awaited first!");
34483 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
34484 return nativeResponseValue;
34486 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
34488 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
34489 if(!isWasmInitialized) {
34490 throw new Error("initializeWasm() must be awaited first!");
34492 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
34493 // debug statements here
34495 // 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);
34497 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 {
34498 if(!isWasmInitialized) {
34499 throw new Error("initializeWasm() must be awaited first!");
34501 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);
34502 return nativeResponseValue;
34504 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
34506 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
34507 if(!isWasmInitialized) {
34508 throw new Error("initializeWasm() must be awaited first!");
34510 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
34511 return nativeResponseValue;
34513 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
34515 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
34516 if(!isWasmInitialized) {
34517 throw new Error("initializeWasm() must be awaited first!");
34519 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
34520 return nativeResponseValue;
34522 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
34524 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
34525 if(!isWasmInitialized) {
34526 throw new Error("initializeWasm() must be awaited first!");
34528 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
34529 return nativeResponseValue;
34531 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
34533 export function ChannelUpdate_free(this_obj: bigint): void {
34534 if(!isWasmInitialized) {
34535 throw new Error("initializeWasm() must be awaited first!");
34537 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
34538 // debug statements here
34540 // struct LDKECDSASignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
34542 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
34543 if(!isWasmInitialized) {
34544 throw new Error("initializeWasm() must be awaited first!");
34546 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
34547 return nativeResponseValue;
34549 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34551 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
34552 if(!isWasmInitialized) {
34553 throw new Error("initializeWasm() must be awaited first!");
34555 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
34556 // debug statements here
34558 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
34560 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
34561 if(!isWasmInitialized) {
34562 throw new Error("initializeWasm() must be awaited first!");
34564 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
34565 return nativeResponseValue;
34567 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
34569 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
34570 if(!isWasmInitialized) {
34571 throw new Error("initializeWasm() must be awaited first!");
34573 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
34574 // debug statements here
34576 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
34578 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
34579 if(!isWasmInitialized) {
34580 throw new Error("initializeWasm() must be awaited first!");
34582 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
34583 return nativeResponseValue;
34585 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
34587 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
34588 if(!isWasmInitialized) {
34589 throw new Error("initializeWasm() must be awaited first!");
34591 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
34592 return nativeResponseValue;
34594 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
34596 export function ChannelUpdate_clone(orig: bigint): bigint {
34597 if(!isWasmInitialized) {
34598 throw new Error("initializeWasm() must be awaited first!");
34600 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
34601 return nativeResponseValue;
34603 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
34605 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
34606 if(!isWasmInitialized) {
34607 throw new Error("initializeWasm() must be awaited first!");
34609 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
34610 return nativeResponseValue;
34612 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
34614 export function QueryChannelRange_free(this_obj: bigint): void {
34615 if(!isWasmInitialized) {
34616 throw new Error("initializeWasm() must be awaited first!");
34618 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
34619 // debug statements here
34621 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
34623 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
34624 if(!isWasmInitialized) {
34625 throw new Error("initializeWasm() must be awaited first!");
34627 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
34628 return nativeResponseValue;
34630 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34632 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
34633 if(!isWasmInitialized) {
34634 throw new Error("initializeWasm() must be awaited first!");
34636 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
34637 // debug statements here
34639 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
34641 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
34642 if(!isWasmInitialized) {
34643 throw new Error("initializeWasm() must be awaited first!");
34645 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
34646 return nativeResponseValue;
34648 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
34650 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
34651 if(!isWasmInitialized) {
34652 throw new Error("initializeWasm() must be awaited first!");
34654 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
34655 // debug statements here
34657 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
34659 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
34660 if(!isWasmInitialized) {
34661 throw new Error("initializeWasm() must be awaited first!");
34663 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
34664 return nativeResponseValue;
34666 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
34668 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
34669 if(!isWasmInitialized) {
34670 throw new Error("initializeWasm() must be awaited first!");
34672 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
34673 // debug statements here
34675 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
34677 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
34678 if(!isWasmInitialized) {
34679 throw new Error("initializeWasm() must be awaited first!");
34681 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
34682 return nativeResponseValue;
34684 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
34686 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
34687 if(!isWasmInitialized) {
34688 throw new Error("initializeWasm() must be awaited first!");
34690 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
34691 return nativeResponseValue;
34693 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
34695 export function QueryChannelRange_clone(orig: bigint): bigint {
34696 if(!isWasmInitialized) {
34697 throw new Error("initializeWasm() must be awaited first!");
34699 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
34700 return nativeResponseValue;
34702 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
34704 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
34705 if(!isWasmInitialized) {
34706 throw new Error("initializeWasm() must be awaited first!");
34708 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
34709 return nativeResponseValue;
34711 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
34713 export function ReplyChannelRange_free(this_obj: bigint): void {
34714 if(!isWasmInitialized) {
34715 throw new Error("initializeWasm() must be awaited first!");
34717 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
34718 // debug statements here
34720 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
34722 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
34723 if(!isWasmInitialized) {
34724 throw new Error("initializeWasm() must be awaited first!");
34726 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
34727 return nativeResponseValue;
34729 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34731 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
34732 if(!isWasmInitialized) {
34733 throw new Error("initializeWasm() must be awaited first!");
34735 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
34736 // debug statements here
34738 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
34740 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
34741 if(!isWasmInitialized) {
34742 throw new Error("initializeWasm() must be awaited first!");
34744 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
34745 return nativeResponseValue;
34747 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
34749 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
34750 if(!isWasmInitialized) {
34751 throw new Error("initializeWasm() must be awaited first!");
34753 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
34754 // debug statements here
34756 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
34758 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
34759 if(!isWasmInitialized) {
34760 throw new Error("initializeWasm() must be awaited first!");
34762 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
34763 return nativeResponseValue;
34765 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
34767 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
34768 if(!isWasmInitialized) {
34769 throw new Error("initializeWasm() must be awaited first!");
34771 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
34772 // debug statements here
34774 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
34776 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
34777 if(!isWasmInitialized) {
34778 throw new Error("initializeWasm() must be awaited first!");
34780 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
34781 return nativeResponseValue;
34783 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
34785 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
34786 if(!isWasmInitialized) {
34787 throw new Error("initializeWasm() must be awaited first!");
34789 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
34790 // debug statements here
34792 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
34794 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
34795 if(!isWasmInitialized) {
34796 throw new Error("initializeWasm() must be awaited first!");
34798 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
34799 return nativeResponseValue;
34801 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
34803 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
34804 if(!isWasmInitialized) {
34805 throw new Error("initializeWasm() must be awaited first!");
34807 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
34808 // debug statements here
34810 // 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);
34812 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 {
34813 if(!isWasmInitialized) {
34814 throw new Error("initializeWasm() must be awaited first!");
34816 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
34817 return nativeResponseValue;
34819 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
34821 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
34822 if(!isWasmInitialized) {
34823 throw new Error("initializeWasm() must be awaited first!");
34825 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
34826 return nativeResponseValue;
34828 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
34830 export function ReplyChannelRange_clone(orig: bigint): bigint {
34831 if(!isWasmInitialized) {
34832 throw new Error("initializeWasm() must be awaited first!");
34834 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
34835 return nativeResponseValue;
34837 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
34839 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
34840 if(!isWasmInitialized) {
34841 throw new Error("initializeWasm() must be awaited first!");
34843 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
34844 return nativeResponseValue;
34846 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
34848 export function QueryShortChannelIds_free(this_obj: bigint): void {
34849 if(!isWasmInitialized) {
34850 throw new Error("initializeWasm() must be awaited first!");
34852 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
34853 // debug statements here
34855 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
34857 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
34858 if(!isWasmInitialized) {
34859 throw new Error("initializeWasm() must be awaited first!");
34861 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
34862 return nativeResponseValue;
34864 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34866 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
34867 if(!isWasmInitialized) {
34868 throw new Error("initializeWasm() must be awaited first!");
34870 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
34871 // debug statements here
34873 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
34875 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
34876 if(!isWasmInitialized) {
34877 throw new Error("initializeWasm() must be awaited first!");
34879 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
34880 return nativeResponseValue;
34882 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
34884 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
34885 if(!isWasmInitialized) {
34886 throw new Error("initializeWasm() must be awaited first!");
34888 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
34889 // debug statements here
34891 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
34893 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
34894 if(!isWasmInitialized) {
34895 throw new Error("initializeWasm() must be awaited first!");
34897 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
34898 return nativeResponseValue;
34900 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
34902 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
34903 if(!isWasmInitialized) {
34904 throw new Error("initializeWasm() must be awaited first!");
34906 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
34907 return nativeResponseValue;
34909 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
34911 export function QueryShortChannelIds_clone(orig: bigint): bigint {
34912 if(!isWasmInitialized) {
34913 throw new Error("initializeWasm() must be awaited first!");
34915 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
34916 return nativeResponseValue;
34918 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
34920 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
34921 if(!isWasmInitialized) {
34922 throw new Error("initializeWasm() must be awaited first!");
34924 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
34925 return nativeResponseValue;
34927 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
34929 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
34930 if(!isWasmInitialized) {
34931 throw new Error("initializeWasm() must be awaited first!");
34933 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
34934 // debug statements here
34936 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
34938 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
34939 if(!isWasmInitialized) {
34940 throw new Error("initializeWasm() must be awaited first!");
34942 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
34943 return nativeResponseValue;
34945 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34947 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
34948 if(!isWasmInitialized) {
34949 throw new Error("initializeWasm() must be awaited first!");
34951 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
34952 // debug statements here
34954 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
34956 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
34957 if(!isWasmInitialized) {
34958 throw new Error("initializeWasm() must be awaited first!");
34960 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
34961 return nativeResponseValue;
34963 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
34965 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
34966 if(!isWasmInitialized) {
34967 throw new Error("initializeWasm() must be awaited first!");
34969 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
34970 // debug statements here
34972 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
34974 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
34975 if(!isWasmInitialized) {
34976 throw new Error("initializeWasm() must be awaited first!");
34978 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
34979 return nativeResponseValue;
34981 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
34983 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
34984 if(!isWasmInitialized) {
34985 throw new Error("initializeWasm() must be awaited first!");
34987 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
34988 return nativeResponseValue;
34990 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
34992 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
34993 if(!isWasmInitialized) {
34994 throw new Error("initializeWasm() must be awaited first!");
34996 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
34997 return nativeResponseValue;
34999 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
35001 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
35002 if(!isWasmInitialized) {
35003 throw new Error("initializeWasm() must be awaited first!");
35005 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
35006 return nativeResponseValue;
35008 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
35010 export function GossipTimestampFilter_free(this_obj: bigint): void {
35011 if(!isWasmInitialized) {
35012 throw new Error("initializeWasm() must be awaited first!");
35014 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
35015 // debug statements here
35017 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
35019 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
35020 if(!isWasmInitialized) {
35021 throw new Error("initializeWasm() must be awaited first!");
35023 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
35024 return nativeResponseValue;
35026 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35028 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
35029 if(!isWasmInitialized) {
35030 throw new Error("initializeWasm() must be awaited first!");
35032 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
35033 // debug statements here
35035 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
35037 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
35038 if(!isWasmInitialized) {
35039 throw new Error("initializeWasm() must be awaited first!");
35041 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
35042 return nativeResponseValue;
35044 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
35046 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
35047 if(!isWasmInitialized) {
35048 throw new Error("initializeWasm() must be awaited first!");
35050 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
35051 // debug statements here
35053 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
35055 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
35056 if(!isWasmInitialized) {
35057 throw new Error("initializeWasm() must be awaited first!");
35059 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
35060 return nativeResponseValue;
35062 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
35064 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
35065 if(!isWasmInitialized) {
35066 throw new Error("initializeWasm() must be awaited first!");
35068 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
35069 // debug statements here
35071 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
35073 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
35074 if(!isWasmInitialized) {
35075 throw new Error("initializeWasm() must be awaited first!");
35077 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
35078 return nativeResponseValue;
35080 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
35082 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
35083 if(!isWasmInitialized) {
35084 throw new Error("initializeWasm() must be awaited first!");
35086 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
35087 return nativeResponseValue;
35089 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
35091 export function GossipTimestampFilter_clone(orig: bigint): bigint {
35092 if(!isWasmInitialized) {
35093 throw new Error("initializeWasm() must be awaited first!");
35095 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
35096 return nativeResponseValue;
35098 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
35100 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
35101 if(!isWasmInitialized) {
35102 throw new Error("initializeWasm() must be awaited first!");
35104 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
35105 return nativeResponseValue;
35107 // void ErrorAction_free(struct LDKErrorAction this_ptr);
35109 export function ErrorAction_free(this_ptr: bigint): void {
35110 if(!isWasmInitialized) {
35111 throw new Error("initializeWasm() must be awaited first!");
35113 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
35114 // debug statements here
35116 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
35118 export function ErrorAction_clone_ptr(arg: bigint): bigint {
35119 if(!isWasmInitialized) {
35120 throw new Error("initializeWasm() must be awaited first!");
35122 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
35123 return nativeResponseValue;
35125 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
35127 export function ErrorAction_clone(orig: bigint): bigint {
35128 if(!isWasmInitialized) {
35129 throw new Error("initializeWasm() must be awaited first!");
35131 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
35132 return nativeResponseValue;
35134 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
35136 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
35137 if(!isWasmInitialized) {
35138 throw new Error("initializeWasm() must be awaited first!");
35140 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
35141 return nativeResponseValue;
35143 // struct LDKErrorAction ErrorAction_disconnect_peer_with_warning(struct LDKWarningMessage msg);
35145 export function ErrorAction_disconnect_peer_with_warning(msg: bigint): bigint {
35146 if(!isWasmInitialized) {
35147 throw new Error("initializeWasm() must be awaited first!");
35149 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer_with_warning(msg);
35150 return nativeResponseValue;
35152 // struct LDKErrorAction ErrorAction_ignore_error(void);
35154 export function ErrorAction_ignore_error(): bigint {
35155 if(!isWasmInitialized) {
35156 throw new Error("initializeWasm() must be awaited first!");
35158 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
35159 return nativeResponseValue;
35161 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
35163 export function ErrorAction_ignore_and_log(a: Level): bigint {
35164 if(!isWasmInitialized) {
35165 throw new Error("initializeWasm() must be awaited first!");
35167 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
35168 return nativeResponseValue;
35170 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
35172 export function ErrorAction_ignore_duplicate_gossip(): bigint {
35173 if(!isWasmInitialized) {
35174 throw new Error("initializeWasm() must be awaited first!");
35176 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
35177 return nativeResponseValue;
35179 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
35181 export function ErrorAction_send_error_message(msg: bigint): bigint {
35182 if(!isWasmInitialized) {
35183 throw new Error("initializeWasm() must be awaited first!");
35185 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
35186 return nativeResponseValue;
35188 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
35190 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
35191 if(!isWasmInitialized) {
35192 throw new Error("initializeWasm() must be awaited first!");
35194 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
35195 return nativeResponseValue;
35197 // void LightningError_free(struct LDKLightningError this_obj);
35199 export function LightningError_free(this_obj: bigint): void {
35200 if(!isWasmInitialized) {
35201 throw new Error("initializeWasm() must be awaited first!");
35203 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
35204 // debug statements here
35206 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
35208 export function LightningError_get_err(this_ptr: bigint): number {
35209 if(!isWasmInitialized) {
35210 throw new Error("initializeWasm() must be awaited first!");
35212 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
35213 return nativeResponseValue;
35215 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
35217 export function LightningError_set_err(this_ptr: bigint, val: number): void {
35218 if(!isWasmInitialized) {
35219 throw new Error("initializeWasm() must be awaited first!");
35221 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
35222 // debug statements here
35224 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
35226 export function LightningError_get_action(this_ptr: bigint): bigint {
35227 if(!isWasmInitialized) {
35228 throw new Error("initializeWasm() must be awaited first!");
35230 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
35231 return nativeResponseValue;
35233 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
35235 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
35236 if(!isWasmInitialized) {
35237 throw new Error("initializeWasm() must be awaited first!");
35239 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
35240 // debug statements here
35242 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
35244 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
35245 if(!isWasmInitialized) {
35246 throw new Error("initializeWasm() must be awaited first!");
35248 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
35249 return nativeResponseValue;
35251 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
35253 export function LightningError_clone_ptr(arg: bigint): bigint {
35254 if(!isWasmInitialized) {
35255 throw new Error("initializeWasm() must be awaited first!");
35257 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
35258 return nativeResponseValue;
35260 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
35262 export function LightningError_clone(orig: bigint): bigint {
35263 if(!isWasmInitialized) {
35264 throw new Error("initializeWasm() must be awaited first!");
35266 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
35267 return nativeResponseValue;
35269 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
35271 export function CommitmentUpdate_free(this_obj: bigint): void {
35272 if(!isWasmInitialized) {
35273 throw new Error("initializeWasm() must be awaited first!");
35275 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
35276 // debug statements here
35278 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35280 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
35281 if(!isWasmInitialized) {
35282 throw new Error("initializeWasm() must be awaited first!");
35284 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
35285 return nativeResponseValue;
35287 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
35289 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
35290 if(!isWasmInitialized) {
35291 throw new Error("initializeWasm() must be awaited first!");
35293 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
35294 // debug statements here
35296 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35298 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
35299 if(!isWasmInitialized) {
35300 throw new Error("initializeWasm() must be awaited first!");
35302 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
35303 return nativeResponseValue;
35305 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
35307 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
35308 if(!isWasmInitialized) {
35309 throw new Error("initializeWasm() must be awaited first!");
35311 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
35312 // debug statements here
35314 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35316 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
35317 if(!isWasmInitialized) {
35318 throw new Error("initializeWasm() must be awaited first!");
35320 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
35321 return nativeResponseValue;
35323 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
35325 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
35326 if(!isWasmInitialized) {
35327 throw new Error("initializeWasm() must be awaited first!");
35329 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
35330 // debug statements here
35332 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35334 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
35335 if(!isWasmInitialized) {
35336 throw new Error("initializeWasm() must be awaited first!");
35338 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
35339 return nativeResponseValue;
35341 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
35343 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
35344 if(!isWasmInitialized) {
35345 throw new Error("initializeWasm() must be awaited first!");
35347 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
35348 // debug statements here
35350 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35352 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
35353 if(!isWasmInitialized) {
35354 throw new Error("initializeWasm() must be awaited first!");
35356 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
35357 return nativeResponseValue;
35359 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
35361 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
35362 if(!isWasmInitialized) {
35363 throw new Error("initializeWasm() must be awaited first!");
35365 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
35366 // debug statements here
35368 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35370 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
35371 if(!isWasmInitialized) {
35372 throw new Error("initializeWasm() must be awaited first!");
35374 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
35375 return nativeResponseValue;
35377 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
35379 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
35380 if(!isWasmInitialized) {
35381 throw new Error("initializeWasm() must be awaited first!");
35383 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
35384 // debug statements here
35386 // 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);
35388 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 {
35389 if(!isWasmInitialized) {
35390 throw new Error("initializeWasm() must be awaited first!");
35392 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);
35393 return nativeResponseValue;
35395 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
35397 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
35398 if(!isWasmInitialized) {
35399 throw new Error("initializeWasm() must be awaited first!");
35401 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
35402 return nativeResponseValue;
35404 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
35406 export function CommitmentUpdate_clone(orig: bigint): bigint {
35407 if(!isWasmInitialized) {
35408 throw new Error("initializeWasm() must be awaited first!");
35410 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
35411 return nativeResponseValue;
35413 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
35415 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
35416 if(!isWasmInitialized) {
35417 throw new Error("initializeWasm() must be awaited first!");
35419 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
35420 return nativeResponseValue;
35422 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
35424 export function ChannelMessageHandler_free(this_ptr: bigint): void {
35425 if(!isWasmInitialized) {
35426 throw new Error("initializeWasm() must be awaited first!");
35428 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
35429 // debug statements here
35431 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
35433 export function RoutingMessageHandler_free(this_ptr: bigint): void {
35434 if(!isWasmInitialized) {
35435 throw new Error("initializeWasm() must be awaited first!");
35437 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
35438 // debug statements here
35440 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
35442 export function OnionMessageHandler_free(this_ptr: bigint): void {
35443 if(!isWasmInitialized) {
35444 throw new Error("initializeWasm() must be awaited first!");
35446 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
35447 // debug statements here
35449 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
35451 export function AcceptChannel_write(obj: bigint): number {
35452 if(!isWasmInitialized) {
35453 throw new Error("initializeWasm() must be awaited first!");
35455 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
35456 return nativeResponseValue;
35458 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
35460 export function AcceptChannel_read(ser: number): bigint {
35461 if(!isWasmInitialized) {
35462 throw new Error("initializeWasm() must be awaited first!");
35464 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
35465 return nativeResponseValue;
35467 // struct LDKCVec_u8Z AcceptChannelV2_write(const struct LDKAcceptChannelV2 *NONNULL_PTR obj);
35469 export function AcceptChannelV2_write(obj: bigint): number {
35470 if(!isWasmInitialized) {
35471 throw new Error("initializeWasm() must be awaited first!");
35473 const nativeResponseValue = wasm.TS_AcceptChannelV2_write(obj);
35474 return nativeResponseValue;
35476 // struct LDKCResult_AcceptChannelV2DecodeErrorZ AcceptChannelV2_read(struct LDKu8slice ser);
35478 export function AcceptChannelV2_read(ser: number): bigint {
35479 if(!isWasmInitialized) {
35480 throw new Error("initializeWasm() must be awaited first!");
35482 const nativeResponseValue = wasm.TS_AcceptChannelV2_read(ser);
35483 return nativeResponseValue;
35485 // struct LDKCVec_u8Z TxAddInput_write(const struct LDKTxAddInput *NONNULL_PTR obj);
35487 export function TxAddInput_write(obj: bigint): number {
35488 if(!isWasmInitialized) {
35489 throw new Error("initializeWasm() must be awaited first!");
35491 const nativeResponseValue = wasm.TS_TxAddInput_write(obj);
35492 return nativeResponseValue;
35494 // struct LDKCResult_TxAddInputDecodeErrorZ TxAddInput_read(struct LDKu8slice ser);
35496 export function TxAddInput_read(ser: number): bigint {
35497 if(!isWasmInitialized) {
35498 throw new Error("initializeWasm() must be awaited first!");
35500 const nativeResponseValue = wasm.TS_TxAddInput_read(ser);
35501 return nativeResponseValue;
35503 // struct LDKCVec_u8Z TxAddOutput_write(const struct LDKTxAddOutput *NONNULL_PTR obj);
35505 export function TxAddOutput_write(obj: bigint): number {
35506 if(!isWasmInitialized) {
35507 throw new Error("initializeWasm() must be awaited first!");
35509 const nativeResponseValue = wasm.TS_TxAddOutput_write(obj);
35510 return nativeResponseValue;
35512 // struct LDKCResult_TxAddOutputDecodeErrorZ TxAddOutput_read(struct LDKu8slice ser);
35514 export function TxAddOutput_read(ser: number): bigint {
35515 if(!isWasmInitialized) {
35516 throw new Error("initializeWasm() must be awaited first!");
35518 const nativeResponseValue = wasm.TS_TxAddOutput_read(ser);
35519 return nativeResponseValue;
35521 // struct LDKCVec_u8Z TxRemoveInput_write(const struct LDKTxRemoveInput *NONNULL_PTR obj);
35523 export function TxRemoveInput_write(obj: bigint): number {
35524 if(!isWasmInitialized) {
35525 throw new Error("initializeWasm() must be awaited first!");
35527 const nativeResponseValue = wasm.TS_TxRemoveInput_write(obj);
35528 return nativeResponseValue;
35530 // struct LDKCResult_TxRemoveInputDecodeErrorZ TxRemoveInput_read(struct LDKu8slice ser);
35532 export function TxRemoveInput_read(ser: number): bigint {
35533 if(!isWasmInitialized) {
35534 throw new Error("initializeWasm() must be awaited first!");
35536 const nativeResponseValue = wasm.TS_TxRemoveInput_read(ser);
35537 return nativeResponseValue;
35539 // struct LDKCVec_u8Z TxRemoveOutput_write(const struct LDKTxRemoveOutput *NONNULL_PTR obj);
35541 export function TxRemoveOutput_write(obj: bigint): number {
35542 if(!isWasmInitialized) {
35543 throw new Error("initializeWasm() must be awaited first!");
35545 const nativeResponseValue = wasm.TS_TxRemoveOutput_write(obj);
35546 return nativeResponseValue;
35548 // struct LDKCResult_TxRemoveOutputDecodeErrorZ TxRemoveOutput_read(struct LDKu8slice ser);
35550 export function TxRemoveOutput_read(ser: number): bigint {
35551 if(!isWasmInitialized) {
35552 throw new Error("initializeWasm() must be awaited first!");
35554 const nativeResponseValue = wasm.TS_TxRemoveOutput_read(ser);
35555 return nativeResponseValue;
35557 // struct LDKCVec_u8Z TxComplete_write(const struct LDKTxComplete *NONNULL_PTR obj);
35559 export function TxComplete_write(obj: bigint): number {
35560 if(!isWasmInitialized) {
35561 throw new Error("initializeWasm() must be awaited first!");
35563 const nativeResponseValue = wasm.TS_TxComplete_write(obj);
35564 return nativeResponseValue;
35566 // struct LDKCResult_TxCompleteDecodeErrorZ TxComplete_read(struct LDKu8slice ser);
35568 export function TxComplete_read(ser: number): bigint {
35569 if(!isWasmInitialized) {
35570 throw new Error("initializeWasm() must be awaited first!");
35572 const nativeResponseValue = wasm.TS_TxComplete_read(ser);
35573 return nativeResponseValue;
35575 // struct LDKCVec_u8Z TxSignatures_write(const struct LDKTxSignatures *NONNULL_PTR obj);
35577 export function TxSignatures_write(obj: bigint): number {
35578 if(!isWasmInitialized) {
35579 throw new Error("initializeWasm() must be awaited first!");
35581 const nativeResponseValue = wasm.TS_TxSignatures_write(obj);
35582 return nativeResponseValue;
35584 // struct LDKCResult_TxSignaturesDecodeErrorZ TxSignatures_read(struct LDKu8slice ser);
35586 export function TxSignatures_read(ser: number): bigint {
35587 if(!isWasmInitialized) {
35588 throw new Error("initializeWasm() must be awaited first!");
35590 const nativeResponseValue = wasm.TS_TxSignatures_read(ser);
35591 return nativeResponseValue;
35593 // struct LDKCVec_u8Z TxInitRbf_write(const struct LDKTxInitRbf *NONNULL_PTR obj);
35595 export function TxInitRbf_write(obj: bigint): number {
35596 if(!isWasmInitialized) {
35597 throw new Error("initializeWasm() must be awaited first!");
35599 const nativeResponseValue = wasm.TS_TxInitRbf_write(obj);
35600 return nativeResponseValue;
35602 // struct LDKCResult_TxInitRbfDecodeErrorZ TxInitRbf_read(struct LDKu8slice ser);
35604 export function TxInitRbf_read(ser: number): bigint {
35605 if(!isWasmInitialized) {
35606 throw new Error("initializeWasm() must be awaited first!");
35608 const nativeResponseValue = wasm.TS_TxInitRbf_read(ser);
35609 return nativeResponseValue;
35611 // struct LDKCVec_u8Z TxAckRbf_write(const struct LDKTxAckRbf *NONNULL_PTR obj);
35613 export function TxAckRbf_write(obj: bigint): number {
35614 if(!isWasmInitialized) {
35615 throw new Error("initializeWasm() must be awaited first!");
35617 const nativeResponseValue = wasm.TS_TxAckRbf_write(obj);
35618 return nativeResponseValue;
35620 // struct LDKCResult_TxAckRbfDecodeErrorZ TxAckRbf_read(struct LDKu8slice ser);
35622 export function TxAckRbf_read(ser: number): bigint {
35623 if(!isWasmInitialized) {
35624 throw new Error("initializeWasm() must be awaited first!");
35626 const nativeResponseValue = wasm.TS_TxAckRbf_read(ser);
35627 return nativeResponseValue;
35629 // struct LDKCVec_u8Z TxAbort_write(const struct LDKTxAbort *NONNULL_PTR obj);
35631 export function TxAbort_write(obj: bigint): number {
35632 if(!isWasmInitialized) {
35633 throw new Error("initializeWasm() must be awaited first!");
35635 const nativeResponseValue = wasm.TS_TxAbort_write(obj);
35636 return nativeResponseValue;
35638 // struct LDKCResult_TxAbortDecodeErrorZ TxAbort_read(struct LDKu8slice ser);
35640 export function TxAbort_read(ser: number): bigint {
35641 if(!isWasmInitialized) {
35642 throw new Error("initializeWasm() must be awaited first!");
35644 const nativeResponseValue = wasm.TS_TxAbort_read(ser);
35645 return nativeResponseValue;
35647 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
35649 export function AnnouncementSignatures_write(obj: bigint): number {
35650 if(!isWasmInitialized) {
35651 throw new Error("initializeWasm() must be awaited first!");
35653 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
35654 return nativeResponseValue;
35656 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
35658 export function AnnouncementSignatures_read(ser: number): bigint {
35659 if(!isWasmInitialized) {
35660 throw new Error("initializeWasm() must be awaited first!");
35662 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
35663 return nativeResponseValue;
35665 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
35667 export function ChannelReestablish_write(obj: bigint): number {
35668 if(!isWasmInitialized) {
35669 throw new Error("initializeWasm() must be awaited first!");
35671 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
35672 return nativeResponseValue;
35674 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
35676 export function ChannelReestablish_read(ser: number): bigint {
35677 if(!isWasmInitialized) {
35678 throw new Error("initializeWasm() must be awaited first!");
35680 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
35681 return nativeResponseValue;
35683 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
35685 export function ClosingSigned_write(obj: bigint): number {
35686 if(!isWasmInitialized) {
35687 throw new Error("initializeWasm() must be awaited first!");
35689 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
35690 return nativeResponseValue;
35692 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
35694 export function ClosingSigned_read(ser: number): bigint {
35695 if(!isWasmInitialized) {
35696 throw new Error("initializeWasm() must be awaited first!");
35698 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
35699 return nativeResponseValue;
35701 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
35703 export function ClosingSignedFeeRange_write(obj: bigint): number {
35704 if(!isWasmInitialized) {
35705 throw new Error("initializeWasm() must be awaited first!");
35707 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
35708 return nativeResponseValue;
35710 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
35712 export function ClosingSignedFeeRange_read(ser: number): bigint {
35713 if(!isWasmInitialized) {
35714 throw new Error("initializeWasm() must be awaited first!");
35716 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
35717 return nativeResponseValue;
35719 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
35721 export function CommitmentSigned_write(obj: bigint): number {
35722 if(!isWasmInitialized) {
35723 throw new Error("initializeWasm() must be awaited first!");
35725 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
35726 return nativeResponseValue;
35728 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
35730 export function CommitmentSigned_read(ser: number): bigint {
35731 if(!isWasmInitialized) {
35732 throw new Error("initializeWasm() must be awaited first!");
35734 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
35735 return nativeResponseValue;
35737 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
35739 export function FundingCreated_write(obj: bigint): number {
35740 if(!isWasmInitialized) {
35741 throw new Error("initializeWasm() must be awaited first!");
35743 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
35744 return nativeResponseValue;
35746 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
35748 export function FundingCreated_read(ser: number): bigint {
35749 if(!isWasmInitialized) {
35750 throw new Error("initializeWasm() must be awaited first!");
35752 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
35753 return nativeResponseValue;
35755 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
35757 export function FundingSigned_write(obj: bigint): number {
35758 if(!isWasmInitialized) {
35759 throw new Error("initializeWasm() must be awaited first!");
35761 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
35762 return nativeResponseValue;
35764 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
35766 export function FundingSigned_read(ser: number): bigint {
35767 if(!isWasmInitialized) {
35768 throw new Error("initializeWasm() must be awaited first!");
35770 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
35771 return nativeResponseValue;
35773 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
35775 export function ChannelReady_write(obj: bigint): number {
35776 if(!isWasmInitialized) {
35777 throw new Error("initializeWasm() must be awaited first!");
35779 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
35780 return nativeResponseValue;
35782 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
35784 export function ChannelReady_read(ser: number): bigint {
35785 if(!isWasmInitialized) {
35786 throw new Error("initializeWasm() must be awaited first!");
35788 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
35789 return nativeResponseValue;
35791 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
35793 export function Init_write(obj: bigint): number {
35794 if(!isWasmInitialized) {
35795 throw new Error("initializeWasm() must be awaited first!");
35797 const nativeResponseValue = wasm.TS_Init_write(obj);
35798 return nativeResponseValue;
35800 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
35802 export function Init_read(ser: number): bigint {
35803 if(!isWasmInitialized) {
35804 throw new Error("initializeWasm() must be awaited first!");
35806 const nativeResponseValue = wasm.TS_Init_read(ser);
35807 return nativeResponseValue;
35809 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
35811 export function OpenChannel_write(obj: bigint): number {
35812 if(!isWasmInitialized) {
35813 throw new Error("initializeWasm() must be awaited first!");
35815 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
35816 return nativeResponseValue;
35818 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
35820 export function OpenChannel_read(ser: number): bigint {
35821 if(!isWasmInitialized) {
35822 throw new Error("initializeWasm() must be awaited first!");
35824 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
35825 return nativeResponseValue;
35827 // struct LDKCVec_u8Z OpenChannelV2_write(const struct LDKOpenChannelV2 *NONNULL_PTR obj);
35829 export function OpenChannelV2_write(obj: bigint): number {
35830 if(!isWasmInitialized) {
35831 throw new Error("initializeWasm() must be awaited first!");
35833 const nativeResponseValue = wasm.TS_OpenChannelV2_write(obj);
35834 return nativeResponseValue;
35836 // struct LDKCResult_OpenChannelV2DecodeErrorZ OpenChannelV2_read(struct LDKu8slice ser);
35838 export function OpenChannelV2_read(ser: number): bigint {
35839 if(!isWasmInitialized) {
35840 throw new Error("initializeWasm() must be awaited first!");
35842 const nativeResponseValue = wasm.TS_OpenChannelV2_read(ser);
35843 return nativeResponseValue;
35845 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
35847 export function RevokeAndACK_write(obj: bigint): number {
35848 if(!isWasmInitialized) {
35849 throw new Error("initializeWasm() must be awaited first!");
35851 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
35852 return nativeResponseValue;
35854 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
35856 export function RevokeAndACK_read(ser: number): bigint {
35857 if(!isWasmInitialized) {
35858 throw new Error("initializeWasm() must be awaited first!");
35860 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
35861 return nativeResponseValue;
35863 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
35865 export function Shutdown_write(obj: bigint): number {
35866 if(!isWasmInitialized) {
35867 throw new Error("initializeWasm() must be awaited first!");
35869 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
35870 return nativeResponseValue;
35872 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
35874 export function Shutdown_read(ser: number): bigint {
35875 if(!isWasmInitialized) {
35876 throw new Error("initializeWasm() must be awaited first!");
35878 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
35879 return nativeResponseValue;
35881 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
35883 export function UpdateFailHTLC_write(obj: bigint): number {
35884 if(!isWasmInitialized) {
35885 throw new Error("initializeWasm() must be awaited first!");
35887 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
35888 return nativeResponseValue;
35890 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
35892 export function UpdateFailHTLC_read(ser: number): bigint {
35893 if(!isWasmInitialized) {
35894 throw new Error("initializeWasm() must be awaited first!");
35896 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
35897 return nativeResponseValue;
35899 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
35901 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
35902 if(!isWasmInitialized) {
35903 throw new Error("initializeWasm() must be awaited first!");
35905 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
35906 return nativeResponseValue;
35908 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
35910 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
35911 if(!isWasmInitialized) {
35912 throw new Error("initializeWasm() must be awaited first!");
35914 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
35915 return nativeResponseValue;
35917 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
35919 export function UpdateFee_write(obj: bigint): number {
35920 if(!isWasmInitialized) {
35921 throw new Error("initializeWasm() must be awaited first!");
35923 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
35924 return nativeResponseValue;
35926 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
35928 export function UpdateFee_read(ser: number): bigint {
35929 if(!isWasmInitialized) {
35930 throw new Error("initializeWasm() must be awaited first!");
35932 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
35933 return nativeResponseValue;
35935 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
35937 export function UpdateFulfillHTLC_write(obj: bigint): number {
35938 if(!isWasmInitialized) {
35939 throw new Error("initializeWasm() must be awaited first!");
35941 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
35942 return nativeResponseValue;
35944 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
35946 export function UpdateFulfillHTLC_read(ser: number): bigint {
35947 if(!isWasmInitialized) {
35948 throw new Error("initializeWasm() must be awaited first!");
35950 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
35951 return nativeResponseValue;
35953 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
35955 export function UpdateAddHTLC_write(obj: bigint): number {
35956 if(!isWasmInitialized) {
35957 throw new Error("initializeWasm() must be awaited first!");
35959 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
35960 return nativeResponseValue;
35962 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
35964 export function UpdateAddHTLC_read(ser: number): bigint {
35965 if(!isWasmInitialized) {
35966 throw new Error("initializeWasm() must be awaited first!");
35968 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
35969 return nativeResponseValue;
35971 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
35973 export function OnionMessage_read(ser: number): bigint {
35974 if(!isWasmInitialized) {
35975 throw new Error("initializeWasm() must be awaited first!");
35977 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
35978 return nativeResponseValue;
35980 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
35982 export function OnionMessage_write(obj: bigint): number {
35983 if(!isWasmInitialized) {
35984 throw new Error("initializeWasm() must be awaited first!");
35986 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
35987 return nativeResponseValue;
35989 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
35991 export function Ping_write(obj: bigint): number {
35992 if(!isWasmInitialized) {
35993 throw new Error("initializeWasm() must be awaited first!");
35995 const nativeResponseValue = wasm.TS_Ping_write(obj);
35996 return nativeResponseValue;
35998 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
36000 export function Ping_read(ser: number): bigint {
36001 if(!isWasmInitialized) {
36002 throw new Error("initializeWasm() must be awaited first!");
36004 const nativeResponseValue = wasm.TS_Ping_read(ser);
36005 return nativeResponseValue;
36007 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
36009 export function Pong_write(obj: bigint): number {
36010 if(!isWasmInitialized) {
36011 throw new Error("initializeWasm() must be awaited first!");
36013 const nativeResponseValue = wasm.TS_Pong_write(obj);
36014 return nativeResponseValue;
36016 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
36018 export function Pong_read(ser: number): bigint {
36019 if(!isWasmInitialized) {
36020 throw new Error("initializeWasm() must be awaited first!");
36022 const nativeResponseValue = wasm.TS_Pong_read(ser);
36023 return nativeResponseValue;
36025 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
36027 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
36028 if(!isWasmInitialized) {
36029 throw new Error("initializeWasm() must be awaited first!");
36031 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
36032 return nativeResponseValue;
36034 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
36036 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
36037 if(!isWasmInitialized) {
36038 throw new Error("initializeWasm() must be awaited first!");
36040 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
36041 return nativeResponseValue;
36043 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
36045 export function ChannelAnnouncement_write(obj: bigint): number {
36046 if(!isWasmInitialized) {
36047 throw new Error("initializeWasm() must be awaited first!");
36049 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
36050 return nativeResponseValue;
36052 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
36054 export function ChannelAnnouncement_read(ser: number): bigint {
36055 if(!isWasmInitialized) {
36056 throw new Error("initializeWasm() must be awaited first!");
36058 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
36059 return nativeResponseValue;
36061 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
36063 export function UnsignedChannelUpdate_write(obj: bigint): number {
36064 if(!isWasmInitialized) {
36065 throw new Error("initializeWasm() must be awaited first!");
36067 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
36068 return nativeResponseValue;
36070 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
36072 export function UnsignedChannelUpdate_read(ser: number): bigint {
36073 if(!isWasmInitialized) {
36074 throw new Error("initializeWasm() must be awaited first!");
36076 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
36077 return nativeResponseValue;
36079 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
36081 export function ChannelUpdate_write(obj: bigint): number {
36082 if(!isWasmInitialized) {
36083 throw new Error("initializeWasm() must be awaited first!");
36085 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
36086 return nativeResponseValue;
36088 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
36090 export function ChannelUpdate_read(ser: number): bigint {
36091 if(!isWasmInitialized) {
36092 throw new Error("initializeWasm() must be awaited first!");
36094 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
36095 return nativeResponseValue;
36097 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
36099 export function ErrorMessage_write(obj: bigint): number {
36100 if(!isWasmInitialized) {
36101 throw new Error("initializeWasm() must be awaited first!");
36103 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
36104 return nativeResponseValue;
36106 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
36108 export function ErrorMessage_read(ser: number): bigint {
36109 if(!isWasmInitialized) {
36110 throw new Error("initializeWasm() must be awaited first!");
36112 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
36113 return nativeResponseValue;
36115 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
36117 export function WarningMessage_write(obj: bigint): number {
36118 if(!isWasmInitialized) {
36119 throw new Error("initializeWasm() must be awaited first!");
36121 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
36122 return nativeResponseValue;
36124 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
36126 export function WarningMessage_read(ser: number): bigint {
36127 if(!isWasmInitialized) {
36128 throw new Error("initializeWasm() must be awaited first!");
36130 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
36131 return nativeResponseValue;
36133 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
36135 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
36136 if(!isWasmInitialized) {
36137 throw new Error("initializeWasm() must be awaited first!");
36139 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
36140 return nativeResponseValue;
36142 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
36144 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
36145 if(!isWasmInitialized) {
36146 throw new Error("initializeWasm() must be awaited first!");
36148 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
36149 return nativeResponseValue;
36151 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
36153 export function NodeAnnouncement_write(obj: bigint): number {
36154 if(!isWasmInitialized) {
36155 throw new Error("initializeWasm() must be awaited first!");
36157 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
36158 return nativeResponseValue;
36160 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
36162 export function NodeAnnouncement_read(ser: number): bigint {
36163 if(!isWasmInitialized) {
36164 throw new Error("initializeWasm() must be awaited first!");
36166 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
36167 return nativeResponseValue;
36169 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
36171 export function QueryShortChannelIds_read(ser: number): bigint {
36172 if(!isWasmInitialized) {
36173 throw new Error("initializeWasm() must be awaited first!");
36175 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
36176 return nativeResponseValue;
36178 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
36180 export function QueryShortChannelIds_write(obj: bigint): number {
36181 if(!isWasmInitialized) {
36182 throw new Error("initializeWasm() must be awaited first!");
36184 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
36185 return nativeResponseValue;
36187 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
36189 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
36190 if(!isWasmInitialized) {
36191 throw new Error("initializeWasm() must be awaited first!");
36193 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
36194 return nativeResponseValue;
36196 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
36198 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
36199 if(!isWasmInitialized) {
36200 throw new Error("initializeWasm() must be awaited first!");
36202 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
36203 return nativeResponseValue;
36205 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
36207 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
36208 if(!isWasmInitialized) {
36209 throw new Error("initializeWasm() must be awaited first!");
36211 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
36212 return nativeResponseValue;
36214 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
36216 export function QueryChannelRange_write(obj: bigint): number {
36217 if(!isWasmInitialized) {
36218 throw new Error("initializeWasm() must be awaited first!");
36220 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
36221 return nativeResponseValue;
36223 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
36225 export function QueryChannelRange_read(ser: number): bigint {
36226 if(!isWasmInitialized) {
36227 throw new Error("initializeWasm() must be awaited first!");
36229 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
36230 return nativeResponseValue;
36232 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
36234 export function ReplyChannelRange_read(ser: number): bigint {
36235 if(!isWasmInitialized) {
36236 throw new Error("initializeWasm() must be awaited first!");
36238 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
36239 return nativeResponseValue;
36241 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
36243 export function ReplyChannelRange_write(obj: bigint): number {
36244 if(!isWasmInitialized) {
36245 throw new Error("initializeWasm() must be awaited first!");
36247 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
36248 return nativeResponseValue;
36250 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
36252 export function GossipTimestampFilter_write(obj: bigint): number {
36253 if(!isWasmInitialized) {
36254 throw new Error("initializeWasm() must be awaited first!");
36256 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
36257 return nativeResponseValue;
36259 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
36261 export function GossipTimestampFilter_read(ser: number): bigint {
36262 if(!isWasmInitialized) {
36263 throw new Error("initializeWasm() must be awaited first!");
36265 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
36266 return nativeResponseValue;
36268 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
36270 export function CustomMessageHandler_free(this_ptr: bigint): void {
36271 if(!isWasmInitialized) {
36272 throw new Error("initializeWasm() must be awaited first!");
36274 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
36275 // debug statements here
36277 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
36279 export function IgnoringMessageHandler_free(this_obj: bigint): void {
36280 if(!isWasmInitialized) {
36281 throw new Error("initializeWasm() must be awaited first!");
36283 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
36284 // debug statements here
36286 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
36288 export function IgnoringMessageHandler_new(): bigint {
36289 if(!isWasmInitialized) {
36290 throw new Error("initializeWasm() must be awaited first!");
36292 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
36293 return nativeResponseValue;
36295 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36297 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
36298 if(!isWasmInitialized) {
36299 throw new Error("initializeWasm() must be awaited first!");
36301 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
36302 return nativeResponseValue;
36304 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36306 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
36307 if(!isWasmInitialized) {
36308 throw new Error("initializeWasm() must be awaited first!");
36310 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
36311 return nativeResponseValue;
36313 // struct LDKOnionMessageProvider IgnoringMessageHandler_as_OnionMessageProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36315 export function IgnoringMessageHandler_as_OnionMessageProvider(this_arg: bigint): bigint {
36316 if(!isWasmInitialized) {
36317 throw new Error("initializeWasm() must be awaited first!");
36319 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageProvider(this_arg);
36320 return nativeResponseValue;
36322 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36324 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
36325 if(!isWasmInitialized) {
36326 throw new Error("initializeWasm() must be awaited first!");
36328 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
36329 return nativeResponseValue;
36331 // struct LDKOffersMessageHandler IgnoringMessageHandler_as_OffersMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36333 export function IgnoringMessageHandler_as_OffersMessageHandler(this_arg: bigint): bigint {
36334 if(!isWasmInitialized) {
36335 throw new Error("initializeWasm() must be awaited first!");
36337 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OffersMessageHandler(this_arg);
36338 return nativeResponseValue;
36340 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36342 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
36343 if(!isWasmInitialized) {
36344 throw new Error("initializeWasm() must be awaited first!");
36346 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
36347 return nativeResponseValue;
36349 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36351 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
36352 if(!isWasmInitialized) {
36353 throw new Error("initializeWasm() must be awaited first!");
36355 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
36356 return nativeResponseValue;
36358 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36360 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
36361 if(!isWasmInitialized) {
36362 throw new Error("initializeWasm() must be awaited first!");
36364 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
36365 return nativeResponseValue;
36367 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
36369 export function ErroringMessageHandler_free(this_obj: bigint): void {
36370 if(!isWasmInitialized) {
36371 throw new Error("initializeWasm() must be awaited first!");
36373 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
36374 // debug statements here
36376 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
36378 export function ErroringMessageHandler_new(): bigint {
36379 if(!isWasmInitialized) {
36380 throw new Error("initializeWasm() must be awaited first!");
36382 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
36383 return nativeResponseValue;
36385 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
36387 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
36388 if(!isWasmInitialized) {
36389 throw new Error("initializeWasm() must be awaited first!");
36391 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
36392 return nativeResponseValue;
36394 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
36396 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
36397 if(!isWasmInitialized) {
36398 throw new Error("initializeWasm() must be awaited first!");
36400 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
36401 return nativeResponseValue;
36403 // void MessageHandler_free(struct LDKMessageHandler this_obj);
36405 export function MessageHandler_free(this_obj: bigint): void {
36406 if(!isWasmInitialized) {
36407 throw new Error("initializeWasm() must be awaited first!");
36409 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
36410 // debug statements here
36412 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36414 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
36415 if(!isWasmInitialized) {
36416 throw new Error("initializeWasm() must be awaited first!");
36418 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
36419 return nativeResponseValue;
36421 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
36423 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
36424 if(!isWasmInitialized) {
36425 throw new Error("initializeWasm() must be awaited first!");
36427 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
36428 // debug statements here
36430 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36432 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
36433 if(!isWasmInitialized) {
36434 throw new Error("initializeWasm() must be awaited first!");
36436 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
36437 return nativeResponseValue;
36439 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
36441 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
36442 if(!isWasmInitialized) {
36443 throw new Error("initializeWasm() must be awaited first!");
36445 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
36446 // debug statements here
36448 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36450 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
36451 if(!isWasmInitialized) {
36452 throw new Error("initializeWasm() must be awaited first!");
36454 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
36455 return nativeResponseValue;
36457 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
36459 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
36460 if(!isWasmInitialized) {
36461 throw new Error("initializeWasm() must be awaited first!");
36463 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
36464 // debug statements here
36466 // const struct LDKCustomMessageHandler *MessageHandler_get_custom_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36468 export function MessageHandler_get_custom_message_handler(this_ptr: bigint): bigint {
36469 if(!isWasmInitialized) {
36470 throw new Error("initializeWasm() must be awaited first!");
36472 const nativeResponseValue = wasm.TS_MessageHandler_get_custom_message_handler(this_ptr);
36473 return nativeResponseValue;
36475 // void MessageHandler_set_custom_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKCustomMessageHandler val);
36477 export function MessageHandler_set_custom_message_handler(this_ptr: bigint, val: bigint): void {
36478 if(!isWasmInitialized) {
36479 throw new Error("initializeWasm() must be awaited first!");
36481 const nativeResponseValue = wasm.TS_MessageHandler_set_custom_message_handler(this_ptr, val);
36482 // debug statements here
36484 // 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);
36486 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint, custom_message_handler_arg: bigint): bigint {
36487 if(!isWasmInitialized) {
36488 throw new Error("initializeWasm() must be awaited first!");
36490 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg, custom_message_handler_arg);
36491 return nativeResponseValue;
36493 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
36495 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
36496 if(!isWasmInitialized) {
36497 throw new Error("initializeWasm() must be awaited first!");
36499 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
36500 return nativeResponseValue;
36502 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
36504 export function SocketDescriptor_clone(orig: bigint): bigint {
36505 if(!isWasmInitialized) {
36506 throw new Error("initializeWasm() must be awaited first!");
36508 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
36509 return nativeResponseValue;
36511 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
36513 export function SocketDescriptor_free(this_ptr: bigint): void {
36514 if(!isWasmInitialized) {
36515 throw new Error("initializeWasm() must be awaited first!");
36517 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
36518 // debug statements here
36520 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
36522 export function PeerHandleError_free(this_obj: bigint): void {
36523 if(!isWasmInitialized) {
36524 throw new Error("initializeWasm() must be awaited first!");
36526 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
36527 // debug statements here
36529 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(void);
36531 export function PeerHandleError_new(): bigint {
36532 if(!isWasmInitialized) {
36533 throw new Error("initializeWasm() must be awaited first!");
36535 const nativeResponseValue = wasm.TS_PeerHandleError_new();
36536 return nativeResponseValue;
36538 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
36540 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
36541 if(!isWasmInitialized) {
36542 throw new Error("initializeWasm() must be awaited first!");
36544 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
36545 return nativeResponseValue;
36547 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
36549 export function PeerHandleError_clone(orig: bigint): bigint {
36550 if(!isWasmInitialized) {
36551 throw new Error("initializeWasm() must be awaited first!");
36553 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
36554 return nativeResponseValue;
36556 // void PeerManager_free(struct LDKPeerManager this_obj);
36558 export function PeerManager_free(this_obj: bigint): void {
36559 if(!isWasmInitialized) {
36560 throw new Error("initializeWasm() must be awaited first!");
36562 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
36563 // debug statements here
36565 // 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);
36567 export function PeerManager_new(message_handler: bigint, current_time: number, ephemeral_random_data: number, logger: bigint, node_signer: bigint): bigint {
36568 if(!isWasmInitialized) {
36569 throw new Error("initializeWasm() must be awaited first!");
36571 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, current_time, ephemeral_random_data, logger, node_signer);
36572 return nativeResponseValue;
36574 // MUST_USE_RES struct LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
36576 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
36577 if(!isWasmInitialized) {
36578 throw new Error("initializeWasm() must be awaited first!");
36580 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
36581 return nativeResponseValue;
36583 // 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_SocketAddressZ remote_network_address);
36585 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
36586 if(!isWasmInitialized) {
36587 throw new Error("initializeWasm() must be awaited first!");
36589 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
36590 return nativeResponseValue;
36592 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor, struct LDKCOption_SocketAddressZ remote_network_address);
36594 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
36595 if(!isWasmInitialized) {
36596 throw new Error("initializeWasm() must be awaited first!");
36598 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
36599 return nativeResponseValue;
36601 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
36603 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
36604 if(!isWasmInitialized) {
36605 throw new Error("initializeWasm() must be awaited first!");
36607 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
36608 return nativeResponseValue;
36610 // 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);
36612 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
36613 if(!isWasmInitialized) {
36614 throw new Error("initializeWasm() must be awaited first!");
36616 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
36617 return nativeResponseValue;
36619 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
36621 export function PeerManager_process_events(this_arg: bigint): void {
36622 if(!isWasmInitialized) {
36623 throw new Error("initializeWasm() must be awaited first!");
36625 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
36626 // debug statements here
36628 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
36630 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
36631 if(!isWasmInitialized) {
36632 throw new Error("initializeWasm() must be awaited first!");
36634 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
36635 // debug statements here
36637 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
36639 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number): void {
36640 if(!isWasmInitialized) {
36641 throw new Error("initializeWasm() must be awaited first!");
36643 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id);
36644 // debug statements here
36646 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
36648 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
36649 if(!isWasmInitialized) {
36650 throw new Error("initializeWasm() must be awaited first!");
36652 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
36653 // debug statements here
36655 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
36657 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
36658 if(!isWasmInitialized) {
36659 throw new Error("initializeWasm() must be awaited first!");
36661 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
36662 // debug statements here
36664 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_SocketAddressZ addresses);
36666 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
36667 if(!isWasmInitialized) {
36668 throw new Error("initializeWasm() must be awaited first!");
36670 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
36671 // debug statements here
36673 // uint64_t htlc_success_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
36675 export function htlc_success_tx_weight(channel_type_features: bigint): bigint {
36676 if(!isWasmInitialized) {
36677 throw new Error("initializeWasm() must be awaited first!");
36679 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(channel_type_features);
36680 return nativeResponseValue;
36682 // uint64_t htlc_timeout_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
36684 export function htlc_timeout_tx_weight(channel_type_features: bigint): bigint {
36685 if(!isWasmInitialized) {
36686 throw new Error("initializeWasm() must be awaited first!");
36688 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(channel_type_features);
36689 return nativeResponseValue;
36691 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
36693 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
36694 if(!isWasmInitialized) {
36695 throw new Error("initializeWasm() must be awaited first!");
36697 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
36698 return nativeResponseValue;
36700 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
36702 export function HTLCClaim_offered_timeout(): HTLCClaim {
36703 if(!isWasmInitialized) {
36704 throw new Error("initializeWasm() must be awaited first!");
36706 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
36707 return nativeResponseValue;
36709 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
36711 export function HTLCClaim_offered_preimage(): HTLCClaim {
36712 if(!isWasmInitialized) {
36713 throw new Error("initializeWasm() must be awaited first!");
36715 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
36716 return nativeResponseValue;
36718 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
36720 export function HTLCClaim_accepted_timeout(): HTLCClaim {
36721 if(!isWasmInitialized) {
36722 throw new Error("initializeWasm() must be awaited first!");
36724 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
36725 return nativeResponseValue;
36727 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
36729 export function HTLCClaim_accepted_preimage(): HTLCClaim {
36730 if(!isWasmInitialized) {
36731 throw new Error("initializeWasm() must be awaited first!");
36733 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
36734 return nativeResponseValue;
36736 // enum LDKHTLCClaim HTLCClaim_revocation(void);
36738 export function HTLCClaim_revocation(): HTLCClaim {
36739 if(!isWasmInitialized) {
36740 throw new Error("initializeWasm() must be awaited first!");
36742 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
36743 return nativeResponseValue;
36745 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
36747 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
36748 if(!isWasmInitialized) {
36749 throw new Error("initializeWasm() must be awaited first!");
36751 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
36752 return nativeResponseValue;
36754 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
36756 export function HTLCClaim_from_witness(witness: number): bigint {
36757 if(!isWasmInitialized) {
36758 throw new Error("initializeWasm() must be awaited first!");
36760 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
36761 return nativeResponseValue;
36763 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
36765 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
36766 if(!isWasmInitialized) {
36767 throw new Error("initializeWasm() must be awaited first!");
36769 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
36770 return nativeResponseValue;
36772 // 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);
36774 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 {
36775 if(!isWasmInitialized) {
36776 throw new Error("initializeWasm() must be awaited first!");
36778 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
36779 return nativeResponseValue;
36781 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
36783 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
36784 if(!isWasmInitialized) {
36785 throw new Error("initializeWasm() must be awaited first!");
36787 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
36788 // debug statements here
36790 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
36792 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
36793 if(!isWasmInitialized) {
36794 throw new Error("initializeWasm() must be awaited first!");
36796 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
36797 return nativeResponseValue;
36799 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
36801 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
36802 if(!isWasmInitialized) {
36803 throw new Error("initializeWasm() must be awaited first!");
36805 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
36806 return nativeResponseValue;
36808 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
36810 export function CounterpartyCommitmentSecrets_new(): bigint {
36811 if(!isWasmInitialized) {
36812 throw new Error("initializeWasm() must be awaited first!");
36814 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
36815 return nativeResponseValue;
36817 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
36819 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
36820 if(!isWasmInitialized) {
36821 throw new Error("initializeWasm() must be awaited first!");
36823 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
36824 return nativeResponseValue;
36826 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
36828 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
36829 if(!isWasmInitialized) {
36830 throw new Error("initializeWasm() must be awaited first!");
36832 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
36833 return nativeResponseValue;
36835 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
36837 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
36838 if(!isWasmInitialized) {
36839 throw new Error("initializeWasm() must be awaited first!");
36841 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
36842 return nativeResponseValue;
36844 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
36846 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
36847 if(!isWasmInitialized) {
36848 throw new Error("initializeWasm() must be awaited first!");
36850 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
36851 return nativeResponseValue;
36853 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
36855 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
36856 if(!isWasmInitialized) {
36857 throw new Error("initializeWasm() must be awaited first!");
36859 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
36860 return nativeResponseValue;
36862 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
36864 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
36865 if(!isWasmInitialized) {
36866 throw new Error("initializeWasm() must be awaited first!");
36868 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
36869 return nativeResponseValue;
36871 // struct LDKPublicKey derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
36873 export function derive_public_key(per_commitment_point: number, base_point: number): number {
36874 if(!isWasmInitialized) {
36875 throw new Error("initializeWasm() must be awaited first!");
36877 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
36878 return nativeResponseValue;
36880 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
36882 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
36883 if(!isWasmInitialized) {
36884 throw new Error("initializeWasm() must be awaited first!");
36886 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
36887 return nativeResponseValue;
36889 // struct LDKPublicKey derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
36891 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
36892 if(!isWasmInitialized) {
36893 throw new Error("initializeWasm() must be awaited first!");
36895 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
36896 return nativeResponseValue;
36898 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
36900 export function TxCreationKeys_free(this_obj: bigint): void {
36901 if(!isWasmInitialized) {
36902 throw new Error("initializeWasm() must be awaited first!");
36904 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
36905 // debug statements here
36907 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
36909 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
36910 if(!isWasmInitialized) {
36911 throw new Error("initializeWasm() must be awaited first!");
36913 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
36914 return nativeResponseValue;
36916 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36918 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
36919 if(!isWasmInitialized) {
36920 throw new Error("initializeWasm() must be awaited first!");
36922 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
36923 // debug statements here
36925 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
36927 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
36928 if(!isWasmInitialized) {
36929 throw new Error("initializeWasm() must be awaited first!");
36931 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
36932 return nativeResponseValue;
36934 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36936 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
36937 if(!isWasmInitialized) {
36938 throw new Error("initializeWasm() must be awaited first!");
36940 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
36941 // debug statements here
36943 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
36945 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
36946 if(!isWasmInitialized) {
36947 throw new Error("initializeWasm() must be awaited first!");
36949 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
36950 return nativeResponseValue;
36952 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36954 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
36955 if(!isWasmInitialized) {
36956 throw new Error("initializeWasm() must be awaited first!");
36958 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
36959 // debug statements here
36961 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
36963 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
36964 if(!isWasmInitialized) {
36965 throw new Error("initializeWasm() must be awaited first!");
36967 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
36968 return nativeResponseValue;
36970 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36972 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
36973 if(!isWasmInitialized) {
36974 throw new Error("initializeWasm() must be awaited first!");
36976 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
36977 // debug statements here
36979 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
36981 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
36982 if(!isWasmInitialized) {
36983 throw new Error("initializeWasm() must be awaited first!");
36985 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
36986 return nativeResponseValue;
36988 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36990 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
36991 if(!isWasmInitialized) {
36992 throw new Error("initializeWasm() must be awaited first!");
36994 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
36995 // debug statements here
36997 // 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);
36999 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 {
37000 if(!isWasmInitialized) {
37001 throw new Error("initializeWasm() must be awaited first!");
37003 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);
37004 return nativeResponseValue;
37006 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
37008 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
37009 if(!isWasmInitialized) {
37010 throw new Error("initializeWasm() must be awaited first!");
37012 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
37013 return nativeResponseValue;
37015 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
37017 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
37018 if(!isWasmInitialized) {
37019 throw new Error("initializeWasm() must be awaited first!");
37021 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
37022 return nativeResponseValue;
37024 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
37026 export function TxCreationKeys_clone(orig: bigint): bigint {
37027 if(!isWasmInitialized) {
37028 throw new Error("initializeWasm() must be awaited first!");
37030 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
37031 return nativeResponseValue;
37033 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
37035 export function TxCreationKeys_write(obj: bigint): number {
37036 if(!isWasmInitialized) {
37037 throw new Error("initializeWasm() must be awaited first!");
37039 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
37040 return nativeResponseValue;
37042 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
37044 export function TxCreationKeys_read(ser: number): bigint {
37045 if(!isWasmInitialized) {
37046 throw new Error("initializeWasm() must be awaited first!");
37048 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
37049 return nativeResponseValue;
37051 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
37053 export function ChannelPublicKeys_free(this_obj: bigint): void {
37054 if(!isWasmInitialized) {
37055 throw new Error("initializeWasm() must be awaited first!");
37057 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
37058 // debug statements here
37060 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37062 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
37063 if(!isWasmInitialized) {
37064 throw new Error("initializeWasm() must be awaited first!");
37066 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
37067 return nativeResponseValue;
37069 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37071 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
37072 if(!isWasmInitialized) {
37073 throw new Error("initializeWasm() must be awaited first!");
37075 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
37076 // debug statements here
37078 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37080 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
37081 if(!isWasmInitialized) {
37082 throw new Error("initializeWasm() must be awaited first!");
37084 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
37085 return nativeResponseValue;
37087 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37089 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
37090 if(!isWasmInitialized) {
37091 throw new Error("initializeWasm() must be awaited first!");
37093 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
37094 // debug statements here
37096 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37098 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
37099 if(!isWasmInitialized) {
37100 throw new Error("initializeWasm() must be awaited first!");
37102 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
37103 return nativeResponseValue;
37105 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37107 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
37108 if(!isWasmInitialized) {
37109 throw new Error("initializeWasm() must be awaited first!");
37111 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
37112 // debug statements here
37114 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37116 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
37117 if(!isWasmInitialized) {
37118 throw new Error("initializeWasm() must be awaited first!");
37120 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
37121 return nativeResponseValue;
37123 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37125 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
37126 if(!isWasmInitialized) {
37127 throw new Error("initializeWasm() must be awaited first!");
37129 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
37130 // debug statements here
37132 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37134 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
37135 if(!isWasmInitialized) {
37136 throw new Error("initializeWasm() must be awaited first!");
37138 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
37139 return nativeResponseValue;
37141 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37143 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
37144 if(!isWasmInitialized) {
37145 throw new Error("initializeWasm() must be awaited first!");
37147 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
37148 // debug statements here
37150 // 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);
37152 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 {
37153 if(!isWasmInitialized) {
37154 throw new Error("initializeWasm() must be awaited first!");
37156 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
37157 return nativeResponseValue;
37159 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
37161 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
37162 if(!isWasmInitialized) {
37163 throw new Error("initializeWasm() must be awaited first!");
37165 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
37166 return nativeResponseValue;
37168 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
37170 export function ChannelPublicKeys_clone(orig: bigint): bigint {
37171 if(!isWasmInitialized) {
37172 throw new Error("initializeWasm() must be awaited first!");
37174 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
37175 return nativeResponseValue;
37177 // uint64_t ChannelPublicKeys_hash(const struct LDKChannelPublicKeys *NONNULL_PTR o);
37179 export function ChannelPublicKeys_hash(o: bigint): bigint {
37180 if(!isWasmInitialized) {
37181 throw new Error("initializeWasm() must be awaited first!");
37183 const nativeResponseValue = wasm.TS_ChannelPublicKeys_hash(o);
37184 return nativeResponseValue;
37186 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
37188 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
37189 if(!isWasmInitialized) {
37190 throw new Error("initializeWasm() must be awaited first!");
37192 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
37193 return nativeResponseValue;
37195 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
37197 export function ChannelPublicKeys_write(obj: bigint): number {
37198 if(!isWasmInitialized) {
37199 throw new Error("initializeWasm() must be awaited first!");
37201 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
37202 return nativeResponseValue;
37204 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
37206 export function ChannelPublicKeys_read(ser: number): bigint {
37207 if(!isWasmInitialized) {
37208 throw new Error("initializeWasm() must be awaited first!");
37210 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
37211 return nativeResponseValue;
37213 // 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);
37215 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 {
37216 if(!isWasmInitialized) {
37217 throw new Error("initializeWasm() must be awaited first!");
37219 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
37220 return nativeResponseValue;
37222 // 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);
37224 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
37225 if(!isWasmInitialized) {
37226 throw new Error("initializeWasm() must be awaited first!");
37228 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
37229 return nativeResponseValue;
37231 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
37233 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
37234 if(!isWasmInitialized) {
37235 throw new Error("initializeWasm() must be awaited first!");
37237 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
37238 return nativeResponseValue;
37240 // struct LDKCVec_u8Z get_counterparty_payment_script(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, struct LDKPublicKey payment_key);
37242 export function get_counterparty_payment_script(channel_type_features: bigint, payment_key: number): number {
37243 if(!isWasmInitialized) {
37244 throw new Error("initializeWasm() must be awaited first!");
37246 const nativeResponseValue = wasm.TS_get_counterparty_payment_script(channel_type_features, payment_key);
37247 return nativeResponseValue;
37249 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
37251 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
37252 if(!isWasmInitialized) {
37253 throw new Error("initializeWasm() must be awaited first!");
37255 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
37256 // debug statements here
37258 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37260 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
37261 if(!isWasmInitialized) {
37262 throw new Error("initializeWasm() must be awaited first!");
37264 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
37265 return nativeResponseValue;
37267 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
37269 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
37270 if(!isWasmInitialized) {
37271 throw new Error("initializeWasm() must be awaited first!");
37273 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
37274 // debug statements here
37276 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37278 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
37279 if(!isWasmInitialized) {
37280 throw new Error("initializeWasm() must be awaited first!");
37282 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
37283 return nativeResponseValue;
37285 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
37287 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
37288 if(!isWasmInitialized) {
37289 throw new Error("initializeWasm() must be awaited first!");
37291 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
37292 // debug statements here
37294 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37296 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
37297 if(!isWasmInitialized) {
37298 throw new Error("initializeWasm() must be awaited first!");
37300 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
37301 return nativeResponseValue;
37303 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
37305 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
37306 if(!isWasmInitialized) {
37307 throw new Error("initializeWasm() must be awaited first!");
37309 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
37310 // debug statements here
37312 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
37314 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
37315 if(!isWasmInitialized) {
37316 throw new Error("initializeWasm() must be awaited first!");
37318 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
37319 return nativeResponseValue;
37321 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37323 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
37324 if(!isWasmInitialized) {
37325 throw new Error("initializeWasm() must be awaited first!");
37327 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
37328 // debug statements here
37330 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37332 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
37333 if(!isWasmInitialized) {
37334 throw new Error("initializeWasm() must be awaited first!");
37336 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
37337 return nativeResponseValue;
37339 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
37341 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
37342 if(!isWasmInitialized) {
37343 throw new Error("initializeWasm() must be awaited first!");
37345 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
37346 // debug statements here
37348 // 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);
37350 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 {
37351 if(!isWasmInitialized) {
37352 throw new Error("initializeWasm() must be awaited first!");
37354 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
37355 return nativeResponseValue;
37357 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
37359 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
37360 if(!isWasmInitialized) {
37361 throw new Error("initializeWasm() must be awaited first!");
37363 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
37364 return nativeResponseValue;
37366 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
37368 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
37369 if(!isWasmInitialized) {
37370 throw new Error("initializeWasm() must be awaited first!");
37372 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
37373 return nativeResponseValue;
37375 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
37377 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
37378 if(!isWasmInitialized) {
37379 throw new Error("initializeWasm() must be awaited first!");
37381 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
37382 return nativeResponseValue;
37384 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
37386 export function HTLCOutputInCommitment_write(obj: bigint): number {
37387 if(!isWasmInitialized) {
37388 throw new Error("initializeWasm() must be awaited first!");
37390 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
37391 return nativeResponseValue;
37393 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
37395 export function HTLCOutputInCommitment_read(ser: number): bigint {
37396 if(!isWasmInitialized) {
37397 throw new Error("initializeWasm() must be awaited first!");
37399 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
37400 return nativeResponseValue;
37402 // 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);
37404 export function get_htlc_redeemscript(htlc: bigint, channel_type_features: bigint, keys: bigint): number {
37405 if(!isWasmInitialized) {
37406 throw new Error("initializeWasm() must be awaited first!");
37408 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, channel_type_features, keys);
37409 return nativeResponseValue;
37411 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
37413 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
37414 if(!isWasmInitialized) {
37415 throw new Error("initializeWasm() must be awaited first!");
37417 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
37418 return nativeResponseValue;
37420 // 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);
37422 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 {
37423 if(!isWasmInitialized) {
37424 throw new Error("initializeWasm() must be awaited first!");
37426 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, channel_type_features, broadcaster_delayed_payment_key, revocation_key);
37427 return nativeResponseValue;
37429 // struct LDKWitness build_htlc_input_witness(struct LDKECDSASignature local_sig, struct LDKECDSASignature remote_sig, struct LDKCOption_ThirtyTwoBytesZ preimage, struct LDKu8slice redeem_script, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
37431 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: bigint, redeem_script: number, channel_type_features: bigint): number {
37432 if(!isWasmInitialized) {
37433 throw new Error("initializeWasm() must be awaited first!");
37435 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, channel_type_features);
37436 return nativeResponseValue;
37438 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
37440 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
37441 if(!isWasmInitialized) {
37442 throw new Error("initializeWasm() must be awaited first!");
37444 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
37445 return nativeResponseValue;
37447 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
37449 export function get_anchor_redeemscript(funding_pubkey: number): number {
37450 if(!isWasmInitialized) {
37451 throw new Error("initializeWasm() must be awaited first!");
37453 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
37454 return nativeResponseValue;
37456 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKECDSASignature funding_sig);
37458 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
37459 if(!isWasmInitialized) {
37460 throw new Error("initializeWasm() must be awaited first!");
37462 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
37463 return nativeResponseValue;
37465 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
37467 export function ChannelTransactionParameters_free(this_obj: bigint): void {
37468 if(!isWasmInitialized) {
37469 throw new Error("initializeWasm() must be awaited first!");
37471 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
37472 // debug statements here
37474 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
37476 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
37477 if(!isWasmInitialized) {
37478 throw new Error("initializeWasm() must be awaited first!");
37480 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
37481 return nativeResponseValue;
37483 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
37485 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
37486 if(!isWasmInitialized) {
37487 throw new Error("initializeWasm() must be awaited first!");
37489 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
37490 // debug statements here
37492 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
37494 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
37495 if(!isWasmInitialized) {
37496 throw new Error("initializeWasm() must be awaited first!");
37498 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
37499 return nativeResponseValue;
37501 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
37503 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
37504 if(!isWasmInitialized) {
37505 throw new Error("initializeWasm() must be awaited first!");
37507 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
37508 // debug statements here
37510 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
37512 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
37513 if(!isWasmInitialized) {
37514 throw new Error("initializeWasm() must be awaited first!");
37516 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
37517 return nativeResponseValue;
37519 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
37521 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
37522 if(!isWasmInitialized) {
37523 throw new Error("initializeWasm() must be awaited first!");
37525 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
37526 // debug statements here
37528 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
37530 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
37531 if(!isWasmInitialized) {
37532 throw new Error("initializeWasm() must be awaited first!");
37534 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
37535 return nativeResponseValue;
37537 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
37539 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
37540 if(!isWasmInitialized) {
37541 throw new Error("initializeWasm() must be awaited first!");
37543 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
37544 // debug statements here
37546 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
37548 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
37549 if(!isWasmInitialized) {
37550 throw new Error("initializeWasm() must be awaited first!");
37552 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
37553 return nativeResponseValue;
37555 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
37557 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
37558 if(!isWasmInitialized) {
37559 throw new Error("initializeWasm() must be awaited first!");
37561 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
37562 // debug statements here
37564 // struct LDKChannelTypeFeatures ChannelTransactionParameters_get_channel_type_features(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
37566 export function ChannelTransactionParameters_get_channel_type_features(this_ptr: bigint): bigint {
37567 if(!isWasmInitialized) {
37568 throw new Error("initializeWasm() must be awaited first!");
37570 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_channel_type_features(this_ptr);
37571 return nativeResponseValue;
37573 // void ChannelTransactionParameters_set_channel_type_features(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
37575 export function ChannelTransactionParameters_set_channel_type_features(this_ptr: bigint, val: bigint): void {
37576 if(!isWasmInitialized) {
37577 throw new Error("initializeWasm() must be awaited first!");
37579 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_channel_type_features(this_ptr, val);
37580 // debug statements here
37582 // 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);
37584 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 {
37585 if(!isWasmInitialized) {
37586 throw new Error("initializeWasm() must be awaited first!");
37588 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);
37589 return nativeResponseValue;
37591 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
37593 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
37594 if(!isWasmInitialized) {
37595 throw new Error("initializeWasm() must be awaited first!");
37597 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
37598 return nativeResponseValue;
37600 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
37602 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
37603 if(!isWasmInitialized) {
37604 throw new Error("initializeWasm() must be awaited first!");
37606 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
37607 return nativeResponseValue;
37609 // uint64_t ChannelTransactionParameters_hash(const struct LDKChannelTransactionParameters *NONNULL_PTR o);
37611 export function ChannelTransactionParameters_hash(o: bigint): bigint {
37612 if(!isWasmInitialized) {
37613 throw new Error("initializeWasm() must be awaited first!");
37615 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_hash(o);
37616 return nativeResponseValue;
37618 // bool ChannelTransactionParameters_eq(const struct LDKChannelTransactionParameters *NONNULL_PTR a, const struct LDKChannelTransactionParameters *NONNULL_PTR b);
37620 export function ChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
37621 if(!isWasmInitialized) {
37622 throw new Error("initializeWasm() must be awaited first!");
37624 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_eq(a, b);
37625 return nativeResponseValue;
37627 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
37629 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
37630 if(!isWasmInitialized) {
37631 throw new Error("initializeWasm() must be awaited first!");
37633 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
37634 // debug statements here
37636 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
37638 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
37639 if(!isWasmInitialized) {
37640 throw new Error("initializeWasm() must be awaited first!");
37642 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
37643 return nativeResponseValue;
37645 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
37647 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
37648 if(!isWasmInitialized) {
37649 throw new Error("initializeWasm() must be awaited first!");
37651 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
37652 // debug statements here
37654 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
37656 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
37657 if(!isWasmInitialized) {
37658 throw new Error("initializeWasm() must be awaited first!");
37660 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
37661 return nativeResponseValue;
37663 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
37665 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
37666 if(!isWasmInitialized) {
37667 throw new Error("initializeWasm() must be awaited first!");
37669 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
37670 // debug statements here
37672 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
37674 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
37675 if(!isWasmInitialized) {
37676 throw new Error("initializeWasm() must be awaited first!");
37678 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
37679 return nativeResponseValue;
37681 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
37683 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
37684 if(!isWasmInitialized) {
37685 throw new Error("initializeWasm() must be awaited first!");
37687 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
37688 return nativeResponseValue;
37690 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
37692 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
37693 if(!isWasmInitialized) {
37694 throw new Error("initializeWasm() must be awaited first!");
37696 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
37697 return nativeResponseValue;
37699 // uint64_t CounterpartyChannelTransactionParameters_hash(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR o);
37701 export function CounterpartyChannelTransactionParameters_hash(o: bigint): bigint {
37702 if(!isWasmInitialized) {
37703 throw new Error("initializeWasm() must be awaited first!");
37705 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_hash(o);
37706 return nativeResponseValue;
37708 // bool CounterpartyChannelTransactionParameters_eq(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR a, const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR b);
37710 export function CounterpartyChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
37711 if(!isWasmInitialized) {
37712 throw new Error("initializeWasm() must be awaited first!");
37714 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_eq(a, b);
37715 return nativeResponseValue;
37717 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
37719 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
37720 if(!isWasmInitialized) {
37721 throw new Error("initializeWasm() must be awaited first!");
37723 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
37724 return nativeResponseValue;
37726 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
37728 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
37729 if(!isWasmInitialized) {
37730 throw new Error("initializeWasm() must be awaited first!");
37732 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
37733 return nativeResponseValue;
37735 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
37737 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
37738 if(!isWasmInitialized) {
37739 throw new Error("initializeWasm() must be awaited first!");
37741 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
37742 return nativeResponseValue;
37744 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
37746 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
37747 if(!isWasmInitialized) {
37748 throw new Error("initializeWasm() must be awaited first!");
37750 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
37751 return nativeResponseValue;
37753 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
37755 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
37756 if(!isWasmInitialized) {
37757 throw new Error("initializeWasm() must be awaited first!");
37759 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
37760 return nativeResponseValue;
37762 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
37764 export function ChannelTransactionParameters_write(obj: bigint): number {
37765 if(!isWasmInitialized) {
37766 throw new Error("initializeWasm() must be awaited first!");
37768 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
37769 return nativeResponseValue;
37771 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
37773 export function ChannelTransactionParameters_read(ser: number): bigint {
37774 if(!isWasmInitialized) {
37775 throw new Error("initializeWasm() must be awaited first!");
37777 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
37778 return nativeResponseValue;
37780 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
37782 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
37783 if(!isWasmInitialized) {
37784 throw new Error("initializeWasm() must be awaited first!");
37786 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
37787 // debug statements here
37789 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
37791 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
37792 if(!isWasmInitialized) {
37793 throw new Error("initializeWasm() must be awaited first!");
37795 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
37796 return nativeResponseValue;
37798 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
37800 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
37801 if(!isWasmInitialized) {
37802 throw new Error("initializeWasm() must be awaited first!");
37804 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
37805 return nativeResponseValue;
37807 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
37809 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
37810 if(!isWasmInitialized) {
37811 throw new Error("initializeWasm() must be awaited first!");
37813 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
37814 return nativeResponseValue;
37816 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
37818 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
37819 if(!isWasmInitialized) {
37820 throw new Error("initializeWasm() must be awaited first!");
37822 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
37823 return nativeResponseValue;
37825 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
37827 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
37828 if(!isWasmInitialized) {
37829 throw new Error("initializeWasm() must be awaited first!");
37831 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
37832 return nativeResponseValue;
37834 // MUST_USE_RES struct LDKChannelTypeFeatures DirectedChannelTransactionParameters_channel_type_features(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
37836 export function DirectedChannelTransactionParameters_channel_type_features(this_arg: bigint): bigint {
37837 if(!isWasmInitialized) {
37838 throw new Error("initializeWasm() must be awaited first!");
37840 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_channel_type_features(this_arg);
37841 return nativeResponseValue;
37843 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
37845 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
37846 if(!isWasmInitialized) {
37847 throw new Error("initializeWasm() must be awaited first!");
37849 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
37850 // debug statements here
37852 // struct LDKECDSASignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
37854 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
37855 if(!isWasmInitialized) {
37856 throw new Error("initializeWasm() must be awaited first!");
37858 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
37859 return nativeResponseValue;
37861 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
37863 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
37864 if(!isWasmInitialized) {
37865 throw new Error("initializeWasm() must be awaited first!");
37867 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
37868 // debug statements here
37870 // struct LDKCVec_ECDSASignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
37872 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
37873 if(!isWasmInitialized) {
37874 throw new Error("initializeWasm() must be awaited first!");
37876 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
37877 return nativeResponseValue;
37879 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
37881 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
37882 if(!isWasmInitialized) {
37883 throw new Error("initializeWasm() must be awaited first!");
37885 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
37886 // debug statements here
37888 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
37890 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
37891 if(!isWasmInitialized) {
37892 throw new Error("initializeWasm() must be awaited first!");
37894 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
37895 return nativeResponseValue;
37897 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
37899 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
37900 if(!isWasmInitialized) {
37901 throw new Error("initializeWasm() must be awaited first!");
37903 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
37904 return nativeResponseValue;
37906 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
37908 export function HolderCommitmentTransaction_write(obj: bigint): number {
37909 if(!isWasmInitialized) {
37910 throw new Error("initializeWasm() must be awaited first!");
37912 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
37913 return nativeResponseValue;
37915 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
37917 export function HolderCommitmentTransaction_read(ser: number): bigint {
37918 if(!isWasmInitialized) {
37919 throw new Error("initializeWasm() must be awaited first!");
37921 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
37922 return nativeResponseValue;
37924 // MUST_USE_RES struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_new(struct LDKCommitmentTransaction commitment_tx, struct LDKECDSASignature counterparty_sig, struct LDKCVec_ECDSASignatureZ counterparty_htlc_sigs, struct LDKPublicKey holder_funding_key, struct LDKPublicKey counterparty_funding_key);
37926 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
37927 if(!isWasmInitialized) {
37928 throw new Error("initializeWasm() must be awaited first!");
37930 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
37931 return nativeResponseValue;
37933 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
37935 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
37936 if(!isWasmInitialized) {
37937 throw new Error("initializeWasm() must be awaited first!");
37939 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
37940 // debug statements here
37942 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
37944 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
37945 if(!isWasmInitialized) {
37946 throw new Error("initializeWasm() must be awaited first!");
37948 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
37949 return nativeResponseValue;
37951 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
37953 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
37954 if(!isWasmInitialized) {
37955 throw new Error("initializeWasm() must be awaited first!");
37957 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
37958 // debug statements here
37960 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
37962 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
37963 if(!isWasmInitialized) {
37964 throw new Error("initializeWasm() must be awaited first!");
37966 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
37967 return nativeResponseValue;
37969 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37971 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
37972 if(!isWasmInitialized) {
37973 throw new Error("initializeWasm() must be awaited first!");
37975 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
37976 // debug statements here
37978 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
37980 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
37981 if(!isWasmInitialized) {
37982 throw new Error("initializeWasm() must be awaited first!");
37984 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
37985 return nativeResponseValue;
37987 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
37989 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
37990 if(!isWasmInitialized) {
37991 throw new Error("initializeWasm() must be awaited first!");
37993 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
37994 return nativeResponseValue;
37996 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
37998 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
37999 if(!isWasmInitialized) {
38000 throw new Error("initializeWasm() must be awaited first!");
38002 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
38003 return nativeResponseValue;
38005 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
38007 export function BuiltCommitmentTransaction_write(obj: bigint): number {
38008 if(!isWasmInitialized) {
38009 throw new Error("initializeWasm() must be awaited first!");
38011 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
38012 return nativeResponseValue;
38014 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
38016 export function BuiltCommitmentTransaction_read(ser: number): bigint {
38017 if(!isWasmInitialized) {
38018 throw new Error("initializeWasm() must be awaited first!");
38020 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
38021 return nativeResponseValue;
38023 // 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);
38025 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38026 if(!isWasmInitialized) {
38027 throw new Error("initializeWasm() must be awaited first!");
38029 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
38030 return nativeResponseValue;
38032 // MUST_USE_RES struct LDKECDSASignature 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);
38034 export function BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38035 if(!isWasmInitialized) {
38036 throw new Error("initializeWasm() must be awaited first!");
38038 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
38039 return nativeResponseValue;
38041 // MUST_USE_RES struct LDKECDSASignature 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);
38043 export function BuiltCommitmentTransaction_sign_holder_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint, entropy_source: bigint): number {
38044 if(!isWasmInitialized) {
38045 throw new Error("initializeWasm() must be awaited first!");
38047 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_holder_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis, entropy_source);
38048 return nativeResponseValue;
38050 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
38052 export function ClosingTransaction_free(this_obj: bigint): void {
38053 if(!isWasmInitialized) {
38054 throw new Error("initializeWasm() must be awaited first!");
38056 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
38057 // debug statements here
38059 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
38061 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
38062 if(!isWasmInitialized) {
38063 throw new Error("initializeWasm() must be awaited first!");
38065 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
38066 return nativeResponseValue;
38068 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
38070 export function ClosingTransaction_clone(orig: bigint): bigint {
38071 if(!isWasmInitialized) {
38072 throw new Error("initializeWasm() must be awaited first!");
38074 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
38075 return nativeResponseValue;
38077 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
38079 export function ClosingTransaction_hash(o: bigint): bigint {
38080 if(!isWasmInitialized) {
38081 throw new Error("initializeWasm() must be awaited first!");
38083 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
38084 return nativeResponseValue;
38086 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
38088 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
38089 if(!isWasmInitialized) {
38090 throw new Error("initializeWasm() must be awaited first!");
38092 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
38093 return nativeResponseValue;
38095 // 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);
38097 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 {
38098 if(!isWasmInitialized) {
38099 throw new Error("initializeWasm() must be awaited first!");
38101 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
38102 return nativeResponseValue;
38104 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38106 export function ClosingTransaction_trust(this_arg: bigint): bigint {
38107 if(!isWasmInitialized) {
38108 throw new Error("initializeWasm() must be awaited first!");
38110 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
38111 return nativeResponseValue;
38113 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
38115 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
38116 if(!isWasmInitialized) {
38117 throw new Error("initializeWasm() must be awaited first!");
38119 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
38120 return nativeResponseValue;
38122 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38124 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
38125 if(!isWasmInitialized) {
38126 throw new Error("initializeWasm() must be awaited first!");
38128 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
38129 return nativeResponseValue;
38131 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38133 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
38134 if(!isWasmInitialized) {
38135 throw new Error("initializeWasm() must be awaited first!");
38137 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
38138 return nativeResponseValue;
38140 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38142 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
38143 if(!isWasmInitialized) {
38144 throw new Error("initializeWasm() must be awaited first!");
38146 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
38147 return nativeResponseValue;
38149 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38151 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
38152 if(!isWasmInitialized) {
38153 throw new Error("initializeWasm() must be awaited first!");
38155 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
38156 return nativeResponseValue;
38158 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
38160 export function TrustedClosingTransaction_free(this_obj: bigint): void {
38161 if(!isWasmInitialized) {
38162 throw new Error("initializeWasm() must be awaited first!");
38164 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
38165 // debug statements here
38167 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
38169 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
38170 if(!isWasmInitialized) {
38171 throw new Error("initializeWasm() must be awaited first!");
38173 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
38174 return nativeResponseValue;
38176 // 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);
38178 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38179 if(!isWasmInitialized) {
38180 throw new Error("initializeWasm() must be awaited first!");
38182 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
38183 return nativeResponseValue;
38185 // MUST_USE_RES struct LDKECDSASignature TrustedClosingTransaction_sign(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
38187 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38188 if(!isWasmInitialized) {
38189 throw new Error("initializeWasm() must be awaited first!");
38191 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
38192 return nativeResponseValue;
38194 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
38196 export function CommitmentTransaction_free(this_obj: bigint): void {
38197 if(!isWasmInitialized) {
38198 throw new Error("initializeWasm() must be awaited first!");
38200 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
38201 // debug statements here
38203 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
38205 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
38206 if(!isWasmInitialized) {
38207 throw new Error("initializeWasm() must be awaited first!");
38209 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
38210 return nativeResponseValue;
38212 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
38214 export function CommitmentTransaction_clone(orig: bigint): bigint {
38215 if(!isWasmInitialized) {
38216 throw new Error("initializeWasm() must be awaited first!");
38218 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
38219 return nativeResponseValue;
38221 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
38223 export function CommitmentTransaction_write(obj: bigint): number {
38224 if(!isWasmInitialized) {
38225 throw new Error("initializeWasm() must be awaited first!");
38227 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
38228 return nativeResponseValue;
38230 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
38232 export function CommitmentTransaction_read(ser: number): bigint {
38233 if(!isWasmInitialized) {
38234 throw new Error("initializeWasm() must be awaited first!");
38236 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
38237 return nativeResponseValue;
38239 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38241 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
38242 if(!isWasmInitialized) {
38243 throw new Error("initializeWasm() must be awaited first!");
38245 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
38246 return nativeResponseValue;
38248 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38250 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
38251 if(!isWasmInitialized) {
38252 throw new Error("initializeWasm() must be awaited first!");
38254 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
38255 return nativeResponseValue;
38257 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38259 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
38260 if(!isWasmInitialized) {
38261 throw new Error("initializeWasm() must be awaited first!");
38263 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
38264 return nativeResponseValue;
38266 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38268 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
38269 if(!isWasmInitialized) {
38270 throw new Error("initializeWasm() must be awaited first!");
38272 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
38273 return nativeResponseValue;
38275 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38277 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
38278 if(!isWasmInitialized) {
38279 throw new Error("initializeWasm() must be awaited first!");
38281 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
38282 return nativeResponseValue;
38284 // 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);
38286 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
38287 if(!isWasmInitialized) {
38288 throw new Error("initializeWasm() must be awaited first!");
38290 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
38291 return nativeResponseValue;
38293 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
38295 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
38296 if(!isWasmInitialized) {
38297 throw new Error("initializeWasm() must be awaited first!");
38299 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
38300 // debug statements here
38302 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38304 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
38305 if(!isWasmInitialized) {
38306 throw new Error("initializeWasm() must be awaited first!");
38308 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
38309 return nativeResponseValue;
38311 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38313 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
38314 if(!isWasmInitialized) {
38315 throw new Error("initializeWasm() must be awaited first!");
38317 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
38318 return nativeResponseValue;
38320 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38322 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
38323 if(!isWasmInitialized) {
38324 throw new Error("initializeWasm() must be awaited first!");
38326 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
38327 return nativeResponseValue;
38329 // MUST_USE_RES struct LDKChannelTypeFeatures TrustedCommitmentTransaction_channel_type_features(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38331 export function TrustedCommitmentTransaction_channel_type_features(this_arg: bigint): bigint {
38332 if(!isWasmInitialized) {
38333 throw new Error("initializeWasm() must be awaited first!");
38335 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_channel_type_features(this_arg);
38336 return nativeResponseValue;
38338 // MUST_USE_RES struct LDKCResult_CVec_ECDSASignatureZNoneZ 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);
38340 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint, entropy_source: bigint): bigint {
38341 if(!isWasmInitialized) {
38342 throw new Error("initializeWasm() must be awaited first!");
38344 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters, entropy_source);
38345 return nativeResponseValue;
38347 // MUST_USE_RES struct LDKCOption_usizeZ TrustedCommitmentTransaction_revokeable_output_index(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38349 export function TrustedCommitmentTransaction_revokeable_output_index(this_arg: bigint): bigint {
38350 if(!isWasmInitialized) {
38351 throw new Error("initializeWasm() must be awaited first!");
38353 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_revokeable_output_index(this_arg);
38354 return nativeResponseValue;
38356 // MUST_USE_RES struct LDKCResult_TransactionNoneZ TrustedCommitmentTransaction_build_to_local_justice_tx(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, uint64_t feerate_per_kw, struct LDKCVec_u8Z destination_script);
38358 export function TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg: bigint, feerate_per_kw: bigint, destination_script: number): bigint {
38359 if(!isWasmInitialized) {
38360 throw new Error("initializeWasm() must be awaited first!");
38362 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg, feerate_per_kw, destination_script);
38363 return nativeResponseValue;
38365 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
38367 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
38368 if(!isWasmInitialized) {
38369 throw new Error("initializeWasm() must be awaited first!");
38371 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
38372 return nativeResponseValue;
38374 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
38376 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
38377 if(!isWasmInitialized) {
38378 throw new Error("initializeWasm() must be awaited first!");
38380 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
38381 return nativeResponseValue;
38383 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
38385 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
38386 if(!isWasmInitialized) {
38387 throw new Error("initializeWasm() must be awaited first!");
38389 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
38390 return nativeResponseValue;
38392 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
38394 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
38395 if(!isWasmInitialized) {
38396 throw new Error("initializeWasm() must be awaited first!");
38398 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
38399 return nativeResponseValue;
38401 // bool Bolt11InvoiceFeatures_eq(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR b);
38403 export function Bolt11InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
38404 if(!isWasmInitialized) {
38405 throw new Error("initializeWasm() must be awaited first!");
38407 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_eq(a, b);
38408 return nativeResponseValue;
38410 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
38412 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
38413 if(!isWasmInitialized) {
38414 throw new Error("initializeWasm() must be awaited first!");
38416 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
38417 return nativeResponseValue;
38419 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
38421 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
38422 if(!isWasmInitialized) {
38423 throw new Error("initializeWasm() must be awaited first!");
38425 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
38426 return nativeResponseValue;
38428 // bool Bolt12InvoiceFeatures_eq(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR b);
38430 export function Bolt12InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
38431 if(!isWasmInitialized) {
38432 throw new Error("initializeWasm() must be awaited first!");
38434 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_eq(a, b);
38435 return nativeResponseValue;
38437 // bool BlindedHopFeatures_eq(const struct LDKBlindedHopFeatures *NONNULL_PTR a, const struct LDKBlindedHopFeatures *NONNULL_PTR b);
38439 export function BlindedHopFeatures_eq(a: bigint, b: bigint): boolean {
38440 if(!isWasmInitialized) {
38441 throw new Error("initializeWasm() must be awaited first!");
38443 const nativeResponseValue = wasm.TS_BlindedHopFeatures_eq(a, b);
38444 return nativeResponseValue;
38446 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
38448 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
38449 if(!isWasmInitialized) {
38450 throw new Error("initializeWasm() must be awaited first!");
38452 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
38453 return nativeResponseValue;
38455 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
38457 export function InitFeatures_clone_ptr(arg: bigint): bigint {
38458 if(!isWasmInitialized) {
38459 throw new Error("initializeWasm() must be awaited first!");
38461 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
38462 return nativeResponseValue;
38464 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
38466 export function InitFeatures_clone(orig: bigint): bigint {
38467 if(!isWasmInitialized) {
38468 throw new Error("initializeWasm() must be awaited first!");
38470 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
38471 return nativeResponseValue;
38473 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
38475 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
38476 if(!isWasmInitialized) {
38477 throw new Error("initializeWasm() must be awaited first!");
38479 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
38480 return nativeResponseValue;
38482 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
38484 export function NodeFeatures_clone(orig: bigint): bigint {
38485 if(!isWasmInitialized) {
38486 throw new Error("initializeWasm() must be awaited first!");
38488 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
38489 return nativeResponseValue;
38491 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
38493 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
38494 if(!isWasmInitialized) {
38495 throw new Error("initializeWasm() must be awaited first!");
38497 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
38498 return nativeResponseValue;
38500 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
38502 export function ChannelFeatures_clone(orig: bigint): bigint {
38503 if(!isWasmInitialized) {
38504 throw new Error("initializeWasm() must be awaited first!");
38506 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
38507 return nativeResponseValue;
38509 // uint64_t Bolt11InvoiceFeatures_clone_ptr(LDKBolt11InvoiceFeatures *NONNULL_PTR arg);
38511 export function Bolt11InvoiceFeatures_clone_ptr(arg: bigint): bigint {
38512 if(!isWasmInitialized) {
38513 throw new Error("initializeWasm() must be awaited first!");
38515 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone_ptr(arg);
38516 return nativeResponseValue;
38518 // struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_clone(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR orig);
38520 export function Bolt11InvoiceFeatures_clone(orig: bigint): bigint {
38521 if(!isWasmInitialized) {
38522 throw new Error("initializeWasm() must be awaited first!");
38524 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone(orig);
38525 return nativeResponseValue;
38527 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
38529 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
38530 if(!isWasmInitialized) {
38531 throw new Error("initializeWasm() must be awaited first!");
38533 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
38534 return nativeResponseValue;
38536 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
38538 export function OfferFeatures_clone(orig: bigint): bigint {
38539 if(!isWasmInitialized) {
38540 throw new Error("initializeWasm() must be awaited first!");
38542 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
38543 return nativeResponseValue;
38545 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
38547 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
38548 if(!isWasmInitialized) {
38549 throw new Error("initializeWasm() must be awaited first!");
38551 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
38552 return nativeResponseValue;
38554 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
38556 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
38557 if(!isWasmInitialized) {
38558 throw new Error("initializeWasm() must be awaited first!");
38560 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
38561 return nativeResponseValue;
38563 // uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg);
38565 export function Bolt12InvoiceFeatures_clone_ptr(arg: bigint): bigint {
38566 if(!isWasmInitialized) {
38567 throw new Error("initializeWasm() must be awaited first!");
38569 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone_ptr(arg);
38570 return nativeResponseValue;
38572 // struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_clone(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR orig);
38574 export function Bolt12InvoiceFeatures_clone(orig: bigint): bigint {
38575 if(!isWasmInitialized) {
38576 throw new Error("initializeWasm() must be awaited first!");
38578 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone(orig);
38579 return nativeResponseValue;
38581 // uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg);
38583 export function BlindedHopFeatures_clone_ptr(arg: bigint): bigint {
38584 if(!isWasmInitialized) {
38585 throw new Error("initializeWasm() must be awaited first!");
38587 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone_ptr(arg);
38588 return nativeResponseValue;
38590 // struct LDKBlindedHopFeatures BlindedHopFeatures_clone(const struct LDKBlindedHopFeatures *NONNULL_PTR orig);
38592 export function BlindedHopFeatures_clone(orig: bigint): bigint {
38593 if(!isWasmInitialized) {
38594 throw new Error("initializeWasm() must be awaited first!");
38596 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone(orig);
38597 return nativeResponseValue;
38599 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
38601 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
38602 if(!isWasmInitialized) {
38603 throw new Error("initializeWasm() must be awaited first!");
38605 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
38606 return nativeResponseValue;
38608 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
38610 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
38611 if(!isWasmInitialized) {
38612 throw new Error("initializeWasm() must be awaited first!");
38614 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
38615 return nativeResponseValue;
38617 // void InitFeatures_free(struct LDKInitFeatures this_obj);
38619 export function InitFeatures_free(this_obj: bigint): void {
38620 if(!isWasmInitialized) {
38621 throw new Error("initializeWasm() must be awaited first!");
38623 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
38624 // debug statements here
38626 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
38628 export function NodeFeatures_free(this_obj: bigint): void {
38629 if(!isWasmInitialized) {
38630 throw new Error("initializeWasm() must be awaited first!");
38632 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
38633 // debug statements here
38635 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
38637 export function ChannelFeatures_free(this_obj: bigint): void {
38638 if(!isWasmInitialized) {
38639 throw new Error("initializeWasm() must be awaited first!");
38641 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
38642 // debug statements here
38644 // void Bolt11InvoiceFeatures_free(struct LDKBolt11InvoiceFeatures this_obj);
38646 export function Bolt11InvoiceFeatures_free(this_obj: bigint): void {
38647 if(!isWasmInitialized) {
38648 throw new Error("initializeWasm() must be awaited first!");
38650 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_free(this_obj);
38651 // debug statements here
38653 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
38655 export function OfferFeatures_free(this_obj: bigint): void {
38656 if(!isWasmInitialized) {
38657 throw new Error("initializeWasm() must be awaited first!");
38659 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
38660 // debug statements here
38662 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
38664 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
38665 if(!isWasmInitialized) {
38666 throw new Error("initializeWasm() must be awaited first!");
38668 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
38669 // debug statements here
38671 // void Bolt12InvoiceFeatures_free(struct LDKBolt12InvoiceFeatures this_obj);
38673 export function Bolt12InvoiceFeatures_free(this_obj: bigint): void {
38674 if(!isWasmInitialized) {
38675 throw new Error("initializeWasm() must be awaited first!");
38677 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_free(this_obj);
38678 // debug statements here
38680 // void BlindedHopFeatures_free(struct LDKBlindedHopFeatures this_obj);
38682 export function BlindedHopFeatures_free(this_obj: bigint): void {
38683 if(!isWasmInitialized) {
38684 throw new Error("initializeWasm() must be awaited first!");
38686 const nativeResponseValue = wasm.TS_BlindedHopFeatures_free(this_obj);
38687 // debug statements here
38689 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
38691 export function ChannelTypeFeatures_free(this_obj: bigint): void {
38692 if(!isWasmInitialized) {
38693 throw new Error("initializeWasm() must be awaited first!");
38695 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
38696 // debug statements here
38698 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
38700 export function InitFeatures_empty(): bigint {
38701 if(!isWasmInitialized) {
38702 throw new Error("initializeWasm() must be awaited first!");
38704 const nativeResponseValue = wasm.TS_InitFeatures_empty();
38705 return nativeResponseValue;
38707 // MUST_USE_RES bool InitFeatures_requires_unknown_bits_from(const struct LDKInitFeatures *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR other);
38709 export function InitFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
38710 if(!isWasmInitialized) {
38711 throw new Error("initializeWasm() must be awaited first!");
38713 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits_from(this_arg, other);
38714 return nativeResponseValue;
38716 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
38718 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
38719 if(!isWasmInitialized) {
38720 throw new Error("initializeWasm() must be awaited first!");
38722 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
38723 return nativeResponseValue;
38725 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38727 export function InitFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
38728 if(!isWasmInitialized) {
38729 throw new Error("initializeWasm() must be awaited first!");
38731 const nativeResponseValue = wasm.TS_InitFeatures_set_required_feature_bit(this_arg, bit);
38732 return nativeResponseValue;
38734 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38736 export function InitFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
38737 if(!isWasmInitialized) {
38738 throw new Error("initializeWasm() must be awaited first!");
38740 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_feature_bit(this_arg, bit);
38741 return nativeResponseValue;
38743 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38745 export function InitFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
38746 if(!isWasmInitialized) {
38747 throw new Error("initializeWasm() must be awaited first!");
38749 const nativeResponseValue = wasm.TS_InitFeatures_set_required_custom_bit(this_arg, bit);
38750 return nativeResponseValue;
38752 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38754 export function InitFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
38755 if(!isWasmInitialized) {
38756 throw new Error("initializeWasm() must be awaited first!");
38758 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_custom_bit(this_arg, bit);
38759 return nativeResponseValue;
38761 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
38763 export function NodeFeatures_empty(): bigint {
38764 if(!isWasmInitialized) {
38765 throw new Error("initializeWasm() must be awaited first!");
38767 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
38768 return nativeResponseValue;
38770 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits_from(const struct LDKNodeFeatures *NONNULL_PTR this_arg, const struct LDKNodeFeatures *NONNULL_PTR other);
38772 export function NodeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
38773 if(!isWasmInitialized) {
38774 throw new Error("initializeWasm() must be awaited first!");
38776 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits_from(this_arg, other);
38777 return nativeResponseValue;
38779 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
38781 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
38782 if(!isWasmInitialized) {
38783 throw new Error("initializeWasm() must be awaited first!");
38785 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
38786 return nativeResponseValue;
38788 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38790 export function NodeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
38791 if(!isWasmInitialized) {
38792 throw new Error("initializeWasm() must be awaited first!");
38794 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_feature_bit(this_arg, bit);
38795 return nativeResponseValue;
38797 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38799 export function NodeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
38800 if(!isWasmInitialized) {
38801 throw new Error("initializeWasm() must be awaited first!");
38803 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_feature_bit(this_arg, bit);
38804 return nativeResponseValue;
38806 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38808 export function NodeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
38809 if(!isWasmInitialized) {
38810 throw new Error("initializeWasm() must be awaited first!");
38812 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_custom_bit(this_arg, bit);
38813 return nativeResponseValue;
38815 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38817 export function NodeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
38818 if(!isWasmInitialized) {
38819 throw new Error("initializeWasm() must be awaited first!");
38821 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_custom_bit(this_arg, bit);
38822 return nativeResponseValue;
38824 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
38826 export function ChannelFeatures_empty(): bigint {
38827 if(!isWasmInitialized) {
38828 throw new Error("initializeWasm() must be awaited first!");
38830 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
38831 return nativeResponseValue;
38833 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits_from(const struct LDKChannelFeatures *NONNULL_PTR this_arg, const struct LDKChannelFeatures *NONNULL_PTR other);
38835 export function ChannelFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
38836 if(!isWasmInitialized) {
38837 throw new Error("initializeWasm() must be awaited first!");
38839 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits_from(this_arg, other);
38840 return nativeResponseValue;
38842 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
38844 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
38845 if(!isWasmInitialized) {
38846 throw new Error("initializeWasm() must be awaited first!");
38848 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
38849 return nativeResponseValue;
38851 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38853 export function ChannelFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
38854 if(!isWasmInitialized) {
38855 throw new Error("initializeWasm() must be awaited first!");
38857 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_feature_bit(this_arg, bit);
38858 return nativeResponseValue;
38860 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38862 export function ChannelFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
38863 if(!isWasmInitialized) {
38864 throw new Error("initializeWasm() must be awaited first!");
38866 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_feature_bit(this_arg, bit);
38867 return nativeResponseValue;
38869 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38871 export function ChannelFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
38872 if(!isWasmInitialized) {
38873 throw new Error("initializeWasm() must be awaited first!");
38875 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_custom_bit(this_arg, bit);
38876 return nativeResponseValue;
38878 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38880 export function ChannelFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
38881 if(!isWasmInitialized) {
38882 throw new Error("initializeWasm() must be awaited first!");
38884 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_custom_bit(this_arg, bit);
38885 return nativeResponseValue;
38887 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_empty(void);
38889 export function Bolt11InvoiceFeatures_empty(): bigint {
38890 if(!isWasmInitialized) {
38891 throw new Error("initializeWasm() must be awaited first!");
38893 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_empty();
38894 return nativeResponseValue;
38896 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR other);
38898 export function Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
38899 if(!isWasmInitialized) {
38900 throw new Error("initializeWasm() must be awaited first!");
38902 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
38903 return nativeResponseValue;
38905 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
38907 export function Bolt11InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
38908 if(!isWasmInitialized) {
38909 throw new Error("initializeWasm() must be awaited first!");
38911 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits(this_arg);
38912 return nativeResponseValue;
38914 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38916 export function Bolt11InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
38917 if(!isWasmInitialized) {
38918 throw new Error("initializeWasm() must be awaited first!");
38920 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_feature_bit(this_arg, bit);
38921 return nativeResponseValue;
38923 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38925 export function Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
38926 if(!isWasmInitialized) {
38927 throw new Error("initializeWasm() must be awaited first!");
38929 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
38930 return nativeResponseValue;
38932 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38934 export function Bolt11InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
38935 if(!isWasmInitialized) {
38936 throw new Error("initializeWasm() must be awaited first!");
38938 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_custom_bit(this_arg, bit);
38939 return nativeResponseValue;
38941 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38943 export function Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
38944 if(!isWasmInitialized) {
38945 throw new Error("initializeWasm() must be awaited first!");
38947 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
38948 return nativeResponseValue;
38950 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
38952 export function OfferFeatures_empty(): bigint {
38953 if(!isWasmInitialized) {
38954 throw new Error("initializeWasm() must be awaited first!");
38956 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
38957 return nativeResponseValue;
38959 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits_from(const struct LDKOfferFeatures *NONNULL_PTR this_arg, const struct LDKOfferFeatures *NONNULL_PTR other);
38961 export function OfferFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
38962 if(!isWasmInitialized) {
38963 throw new Error("initializeWasm() must be awaited first!");
38965 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits_from(this_arg, other);
38966 return nativeResponseValue;
38968 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
38970 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
38971 if(!isWasmInitialized) {
38972 throw new Error("initializeWasm() must be awaited first!");
38974 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
38975 return nativeResponseValue;
38977 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38979 export function OfferFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
38980 if(!isWasmInitialized) {
38981 throw new Error("initializeWasm() must be awaited first!");
38983 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_feature_bit(this_arg, bit);
38984 return nativeResponseValue;
38986 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38988 export function OfferFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
38989 if(!isWasmInitialized) {
38990 throw new Error("initializeWasm() must be awaited first!");
38992 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_feature_bit(this_arg, bit);
38993 return nativeResponseValue;
38995 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
38997 export function OfferFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
38998 if(!isWasmInitialized) {
38999 throw new Error("initializeWasm() must be awaited first!");
39001 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_custom_bit(this_arg, bit);
39002 return nativeResponseValue;
39004 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39006 export function OfferFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39007 if(!isWasmInitialized) {
39008 throw new Error("initializeWasm() must be awaited first!");
39010 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_custom_bit(this_arg, bit);
39011 return nativeResponseValue;
39013 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
39015 export function InvoiceRequestFeatures_empty(): bigint {
39016 if(!isWasmInitialized) {
39017 throw new Error("initializeWasm() must be awaited first!");
39019 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
39020 return nativeResponseValue;
39022 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits_from(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, const struct LDKInvoiceRequestFeatures *NONNULL_PTR other);
39024 export function InvoiceRequestFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39025 if(!isWasmInitialized) {
39026 throw new Error("initializeWasm() must be awaited first!");
39028 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits_from(this_arg, other);
39029 return nativeResponseValue;
39031 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
39033 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39034 if(!isWasmInitialized) {
39035 throw new Error("initializeWasm() must be awaited first!");
39037 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
39038 return nativeResponseValue;
39040 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39042 export function InvoiceRequestFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39043 if(!isWasmInitialized) {
39044 throw new Error("initializeWasm() must be awaited first!");
39046 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_feature_bit(this_arg, bit);
39047 return nativeResponseValue;
39049 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39051 export function InvoiceRequestFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39052 if(!isWasmInitialized) {
39053 throw new Error("initializeWasm() must be awaited first!");
39055 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_feature_bit(this_arg, bit);
39056 return nativeResponseValue;
39058 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39060 export function InvoiceRequestFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39061 if(!isWasmInitialized) {
39062 throw new Error("initializeWasm() must be awaited first!");
39064 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_custom_bit(this_arg, bit);
39065 return nativeResponseValue;
39067 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39069 export function InvoiceRequestFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39070 if(!isWasmInitialized) {
39071 throw new Error("initializeWasm() must be awaited first!");
39073 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_custom_bit(this_arg, bit);
39074 return nativeResponseValue;
39076 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_empty(void);
39078 export function Bolt12InvoiceFeatures_empty(): bigint {
39079 if(!isWasmInitialized) {
39080 throw new Error("initializeWasm() must be awaited first!");
39082 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_empty();
39083 return nativeResponseValue;
39085 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR other);
39087 export function Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39088 if(!isWasmInitialized) {
39089 throw new Error("initializeWasm() must be awaited first!");
39091 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
39092 return nativeResponseValue;
39094 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
39096 export function Bolt12InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39097 if(!isWasmInitialized) {
39098 throw new Error("initializeWasm() must be awaited first!");
39100 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits(this_arg);
39101 return nativeResponseValue;
39103 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39105 export function Bolt12InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39106 if(!isWasmInitialized) {
39107 throw new Error("initializeWasm() must be awaited first!");
39109 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_feature_bit(this_arg, bit);
39110 return nativeResponseValue;
39112 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39114 export function Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39115 if(!isWasmInitialized) {
39116 throw new Error("initializeWasm() must be awaited first!");
39118 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
39119 return nativeResponseValue;
39121 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39123 export function Bolt12InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39124 if(!isWasmInitialized) {
39125 throw new Error("initializeWasm() must be awaited first!");
39127 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_custom_bit(this_arg, bit);
39128 return nativeResponseValue;
39130 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39132 export function Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39133 if(!isWasmInitialized) {
39134 throw new Error("initializeWasm() must be awaited first!");
39136 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
39137 return nativeResponseValue;
39139 // MUST_USE_RES struct LDKBlindedHopFeatures BlindedHopFeatures_empty(void);
39141 export function BlindedHopFeatures_empty(): bigint {
39142 if(!isWasmInitialized) {
39143 throw new Error("initializeWasm() must be awaited first!");
39145 const nativeResponseValue = wasm.TS_BlindedHopFeatures_empty();
39146 return nativeResponseValue;
39148 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits_from(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, const struct LDKBlindedHopFeatures *NONNULL_PTR other);
39150 export function BlindedHopFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39151 if(!isWasmInitialized) {
39152 throw new Error("initializeWasm() must be awaited first!");
39154 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits_from(this_arg, other);
39155 return nativeResponseValue;
39157 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg);
39159 export function BlindedHopFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39160 if(!isWasmInitialized) {
39161 throw new Error("initializeWasm() must be awaited first!");
39163 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits(this_arg);
39164 return nativeResponseValue;
39166 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39168 export function BlindedHopFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39169 if(!isWasmInitialized) {
39170 throw new Error("initializeWasm() must be awaited first!");
39172 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_feature_bit(this_arg, bit);
39173 return nativeResponseValue;
39175 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39177 export function BlindedHopFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39178 if(!isWasmInitialized) {
39179 throw new Error("initializeWasm() must be awaited first!");
39181 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_feature_bit(this_arg, bit);
39182 return nativeResponseValue;
39184 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39186 export function BlindedHopFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39187 if(!isWasmInitialized) {
39188 throw new Error("initializeWasm() must be awaited first!");
39190 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_custom_bit(this_arg, bit);
39191 return nativeResponseValue;
39193 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39195 export function BlindedHopFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39196 if(!isWasmInitialized) {
39197 throw new Error("initializeWasm() must be awaited first!");
39199 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_custom_bit(this_arg, bit);
39200 return nativeResponseValue;
39202 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
39204 export function ChannelTypeFeatures_empty(): bigint {
39205 if(!isWasmInitialized) {
39206 throw new Error("initializeWasm() must be awaited first!");
39208 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
39209 return nativeResponseValue;
39211 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits_from(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, const struct LDKChannelTypeFeatures *NONNULL_PTR other);
39213 export function ChannelTypeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39214 if(!isWasmInitialized) {
39215 throw new Error("initializeWasm() must be awaited first!");
39217 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits_from(this_arg, other);
39218 return nativeResponseValue;
39220 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39222 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39223 if(!isWasmInitialized) {
39224 throw new Error("initializeWasm() must be awaited first!");
39226 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
39227 return nativeResponseValue;
39229 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39231 export function ChannelTypeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39232 if(!isWasmInitialized) {
39233 throw new Error("initializeWasm() must be awaited first!");
39235 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_feature_bit(this_arg, bit);
39236 return nativeResponseValue;
39238 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39240 export function ChannelTypeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39241 if(!isWasmInitialized) {
39242 throw new Error("initializeWasm() must be awaited first!");
39244 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_feature_bit(this_arg, bit);
39245 return nativeResponseValue;
39247 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39249 export function ChannelTypeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39250 if(!isWasmInitialized) {
39251 throw new Error("initializeWasm() must be awaited first!");
39253 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_custom_bit(this_arg, bit);
39254 return nativeResponseValue;
39256 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39258 export function ChannelTypeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39259 if(!isWasmInitialized) {
39260 throw new Error("initializeWasm() must be awaited first!");
39262 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_custom_bit(this_arg, bit);
39263 return nativeResponseValue;
39265 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
39267 export function InitFeatures_write(obj: bigint): number {
39268 if(!isWasmInitialized) {
39269 throw new Error("initializeWasm() must be awaited first!");
39271 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
39272 return nativeResponseValue;
39274 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
39276 export function InitFeatures_read(ser: number): bigint {
39277 if(!isWasmInitialized) {
39278 throw new Error("initializeWasm() must be awaited first!");
39280 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
39281 return nativeResponseValue;
39283 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
39285 export function ChannelFeatures_write(obj: bigint): number {
39286 if(!isWasmInitialized) {
39287 throw new Error("initializeWasm() must be awaited first!");
39289 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
39290 return nativeResponseValue;
39292 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
39294 export function ChannelFeatures_read(ser: number): bigint {
39295 if(!isWasmInitialized) {
39296 throw new Error("initializeWasm() must be awaited first!");
39298 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
39299 return nativeResponseValue;
39301 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
39303 export function NodeFeatures_write(obj: bigint): number {
39304 if(!isWasmInitialized) {
39305 throw new Error("initializeWasm() must be awaited first!");
39307 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
39308 return nativeResponseValue;
39310 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
39312 export function NodeFeatures_read(ser: number): bigint {
39313 if(!isWasmInitialized) {
39314 throw new Error("initializeWasm() must be awaited first!");
39316 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
39317 return nativeResponseValue;
39319 // struct LDKCVec_u8Z Bolt11InvoiceFeatures_write(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR obj);
39321 export function Bolt11InvoiceFeatures_write(obj: bigint): number {
39322 if(!isWasmInitialized) {
39323 throw new Error("initializeWasm() must be awaited first!");
39325 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_write(obj);
39326 return nativeResponseValue;
39328 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ Bolt11InvoiceFeatures_read(struct LDKu8slice ser);
39330 export function Bolt11InvoiceFeatures_read(ser: number): bigint {
39331 if(!isWasmInitialized) {
39332 throw new Error("initializeWasm() must be awaited first!");
39334 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_read(ser);
39335 return nativeResponseValue;
39337 // struct LDKCVec_u8Z Bolt12InvoiceFeatures_write(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR obj);
39339 export function Bolt12InvoiceFeatures_write(obj: bigint): number {
39340 if(!isWasmInitialized) {
39341 throw new Error("initializeWasm() must be awaited first!");
39343 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_write(obj);
39344 return nativeResponseValue;
39346 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ Bolt12InvoiceFeatures_read(struct LDKu8slice ser);
39348 export function Bolt12InvoiceFeatures_read(ser: number): bigint {
39349 if(!isWasmInitialized) {
39350 throw new Error("initializeWasm() must be awaited first!");
39352 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_read(ser);
39353 return nativeResponseValue;
39355 // struct LDKCVec_u8Z BlindedHopFeatures_write(const struct LDKBlindedHopFeatures *NONNULL_PTR obj);
39357 export function BlindedHopFeatures_write(obj: bigint): number {
39358 if(!isWasmInitialized) {
39359 throw new Error("initializeWasm() must be awaited first!");
39361 const nativeResponseValue = wasm.TS_BlindedHopFeatures_write(obj);
39362 return nativeResponseValue;
39364 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ BlindedHopFeatures_read(struct LDKu8slice ser);
39366 export function BlindedHopFeatures_read(ser: number): bigint {
39367 if(!isWasmInitialized) {
39368 throw new Error("initializeWasm() must be awaited first!");
39370 const nativeResponseValue = wasm.TS_BlindedHopFeatures_read(ser);
39371 return nativeResponseValue;
39373 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
39375 export function ChannelTypeFeatures_write(obj: bigint): number {
39376 if(!isWasmInitialized) {
39377 throw new Error("initializeWasm() must be awaited first!");
39379 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
39380 return nativeResponseValue;
39382 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
39384 export function ChannelTypeFeatures_read(ser: number): bigint {
39385 if(!isWasmInitialized) {
39386 throw new Error("initializeWasm() must be awaited first!");
39388 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
39389 return nativeResponseValue;
39391 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39393 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
39394 if(!isWasmInitialized) {
39395 throw new Error("initializeWasm() must be awaited first!");
39397 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
39398 // debug statements here
39400 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39402 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
39403 if(!isWasmInitialized) {
39404 throw new Error("initializeWasm() must be awaited first!");
39406 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
39407 // debug statements here
39409 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39411 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
39412 if(!isWasmInitialized) {
39413 throw new Error("initializeWasm() must be awaited first!");
39415 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
39416 return nativeResponseValue;
39418 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39420 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
39421 if(!isWasmInitialized) {
39422 throw new Error("initializeWasm() must be awaited first!");
39424 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
39425 // debug statements here
39427 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39429 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
39430 if(!isWasmInitialized) {
39431 throw new Error("initializeWasm() must be awaited first!");
39433 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
39434 // debug statements here
39436 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39438 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
39439 if(!isWasmInitialized) {
39440 throw new Error("initializeWasm() must be awaited first!");
39442 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
39443 return nativeResponseValue;
39445 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39447 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
39448 if(!isWasmInitialized) {
39449 throw new Error("initializeWasm() must be awaited first!");
39451 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
39452 return nativeResponseValue;
39454 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39456 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
39457 if(!isWasmInitialized) {
39458 throw new Error("initializeWasm() must be awaited first!");
39460 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
39461 return nativeResponseValue;
39463 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39465 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
39466 if(!isWasmInitialized) {
39467 throw new Error("initializeWasm() must be awaited first!");
39469 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
39470 // debug statements here
39472 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39474 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
39475 if(!isWasmInitialized) {
39476 throw new Error("initializeWasm() must be awaited first!");
39478 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
39479 // debug statements here
39481 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39483 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
39484 if(!isWasmInitialized) {
39485 throw new Error("initializeWasm() must be awaited first!");
39487 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
39488 return nativeResponseValue;
39490 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39492 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
39493 if(!isWasmInitialized) {
39494 throw new Error("initializeWasm() must be awaited first!");
39496 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
39497 // debug statements here
39499 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39501 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
39502 if(!isWasmInitialized) {
39503 throw new Error("initializeWasm() must be awaited first!");
39505 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
39506 // debug statements here
39508 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39510 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
39511 if(!isWasmInitialized) {
39512 throw new Error("initializeWasm() must be awaited first!");
39514 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
39515 return nativeResponseValue;
39517 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39519 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
39520 if(!isWasmInitialized) {
39521 throw new Error("initializeWasm() must be awaited first!");
39523 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
39524 // debug statements here
39526 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39528 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
39529 if(!isWasmInitialized) {
39530 throw new Error("initializeWasm() must be awaited first!");
39532 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
39533 // debug statements here
39535 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39537 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
39538 if(!isWasmInitialized) {
39539 throw new Error("initializeWasm() must be awaited first!");
39541 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
39542 return nativeResponseValue;
39544 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39546 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
39547 if(!isWasmInitialized) {
39548 throw new Error("initializeWasm() must be awaited first!");
39550 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
39551 return nativeResponseValue;
39553 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39555 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
39556 if(!isWasmInitialized) {
39557 throw new Error("initializeWasm() must be awaited first!");
39559 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
39560 return nativeResponseValue;
39562 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39564 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
39565 if(!isWasmInitialized) {
39566 throw new Error("initializeWasm() must be awaited first!");
39568 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
39569 // debug statements here
39571 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39573 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
39574 if(!isWasmInitialized) {
39575 throw new Error("initializeWasm() must be awaited first!");
39577 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
39578 // debug statements here
39580 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39582 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
39583 if(!isWasmInitialized) {
39584 throw new Error("initializeWasm() must be awaited first!");
39586 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
39587 return nativeResponseValue;
39589 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39591 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
39592 if(!isWasmInitialized) {
39593 throw new Error("initializeWasm() must be awaited first!");
39595 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
39596 // debug statements here
39598 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39600 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
39601 if(!isWasmInitialized) {
39602 throw new Error("initializeWasm() must be awaited first!");
39604 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
39605 // debug statements here
39607 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39609 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
39610 if(!isWasmInitialized) {
39611 throw new Error("initializeWasm() must be awaited first!");
39613 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
39614 return nativeResponseValue;
39616 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39618 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
39619 if(!isWasmInitialized) {
39620 throw new Error("initializeWasm() must be awaited first!");
39622 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
39623 return nativeResponseValue;
39625 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39627 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
39628 if(!isWasmInitialized) {
39629 throw new Error("initializeWasm() must be awaited first!");
39631 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
39632 return nativeResponseValue;
39634 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39636 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
39637 if(!isWasmInitialized) {
39638 throw new Error("initializeWasm() must be awaited first!");
39640 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
39641 // debug statements here
39643 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39645 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
39646 if(!isWasmInitialized) {
39647 throw new Error("initializeWasm() must be awaited first!");
39649 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
39650 // debug statements here
39652 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39654 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
39655 if(!isWasmInitialized) {
39656 throw new Error("initializeWasm() must be awaited first!");
39658 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
39659 return nativeResponseValue;
39661 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39663 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
39664 if(!isWasmInitialized) {
39665 throw new Error("initializeWasm() must be awaited first!");
39667 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
39668 // debug statements here
39670 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39672 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
39673 if(!isWasmInitialized) {
39674 throw new Error("initializeWasm() must be awaited first!");
39676 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
39677 // debug statements here
39679 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39681 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
39682 if(!isWasmInitialized) {
39683 throw new Error("initializeWasm() must be awaited first!");
39685 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
39686 return nativeResponseValue;
39688 // void Bolt11InvoiceFeatures_set_variable_length_onion_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39690 export function Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
39691 if(!isWasmInitialized) {
39692 throw new Error("initializeWasm() must be awaited first!");
39694 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg);
39695 // debug statements here
39697 // void Bolt11InvoiceFeatures_set_variable_length_onion_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39699 export function Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
39700 if(!isWasmInitialized) {
39701 throw new Error("initializeWasm() must be awaited first!");
39703 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg);
39704 // debug statements here
39706 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39708 export function Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
39709 if(!isWasmInitialized) {
39710 throw new Error("initializeWasm() must be awaited first!");
39712 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg);
39713 return nativeResponseValue;
39715 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39717 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
39718 if(!isWasmInitialized) {
39719 throw new Error("initializeWasm() must be awaited first!");
39721 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
39722 return nativeResponseValue;
39724 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39726 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
39727 if(!isWasmInitialized) {
39728 throw new Error("initializeWasm() must be awaited first!");
39730 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
39731 return nativeResponseValue;
39733 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39735 export function Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
39736 if(!isWasmInitialized) {
39737 throw new Error("initializeWasm() must be awaited first!");
39739 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg);
39740 return nativeResponseValue;
39742 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39744 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
39745 if(!isWasmInitialized) {
39746 throw new Error("initializeWasm() must be awaited first!");
39748 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
39749 // debug statements here
39751 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39753 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
39754 if(!isWasmInitialized) {
39755 throw new Error("initializeWasm() must be awaited first!");
39757 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
39758 // debug statements here
39760 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39762 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
39763 if(!isWasmInitialized) {
39764 throw new Error("initializeWasm() must be awaited first!");
39766 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
39767 return nativeResponseValue;
39769 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39771 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
39772 if(!isWasmInitialized) {
39773 throw new Error("initializeWasm() must be awaited first!");
39775 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
39776 // debug statements here
39778 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39780 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
39781 if(!isWasmInitialized) {
39782 throw new Error("initializeWasm() must be awaited first!");
39784 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
39785 // debug statements here
39787 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39789 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
39790 if(!isWasmInitialized) {
39791 throw new Error("initializeWasm() must be awaited first!");
39793 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
39794 return nativeResponseValue;
39796 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39798 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
39799 if(!isWasmInitialized) {
39800 throw new Error("initializeWasm() must be awaited first!");
39802 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
39803 // debug statements here
39805 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39807 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
39808 if(!isWasmInitialized) {
39809 throw new Error("initializeWasm() must be awaited first!");
39811 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
39812 // debug statements here
39814 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39816 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
39817 if(!isWasmInitialized) {
39818 throw new Error("initializeWasm() must be awaited first!");
39820 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
39821 return nativeResponseValue;
39823 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39825 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
39826 if(!isWasmInitialized) {
39827 throw new Error("initializeWasm() must be awaited first!");
39829 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
39830 return nativeResponseValue;
39832 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39834 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
39835 if(!isWasmInitialized) {
39836 throw new Error("initializeWasm() must be awaited first!");
39838 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
39839 return nativeResponseValue;
39841 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39843 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
39844 if(!isWasmInitialized) {
39845 throw new Error("initializeWasm() must be awaited first!");
39847 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
39848 return nativeResponseValue;
39850 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39852 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
39853 if(!isWasmInitialized) {
39854 throw new Error("initializeWasm() must be awaited first!");
39856 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
39857 // debug statements here
39859 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39861 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
39862 if(!isWasmInitialized) {
39863 throw new Error("initializeWasm() must be awaited first!");
39865 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
39866 // debug statements here
39868 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39870 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
39871 if(!isWasmInitialized) {
39872 throw new Error("initializeWasm() must be awaited first!");
39874 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
39875 return nativeResponseValue;
39877 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39879 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
39880 if(!isWasmInitialized) {
39881 throw new Error("initializeWasm() must be awaited first!");
39883 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
39884 // debug statements here
39886 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39888 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
39889 if(!isWasmInitialized) {
39890 throw new Error("initializeWasm() must be awaited first!");
39892 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
39893 // debug statements here
39895 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39897 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
39898 if(!isWasmInitialized) {
39899 throw new Error("initializeWasm() must be awaited first!");
39901 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
39902 return nativeResponseValue;
39904 // void Bolt11InvoiceFeatures_set_payment_secret_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39906 export function Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
39907 if(!isWasmInitialized) {
39908 throw new Error("initializeWasm() must be awaited first!");
39910 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg);
39911 // debug statements here
39913 // void Bolt11InvoiceFeatures_set_payment_secret_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39915 export function Bolt11InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
39916 if(!isWasmInitialized) {
39917 throw new Error("initializeWasm() must be awaited first!");
39919 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_required(this_arg);
39920 // debug statements here
39922 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39924 export function Bolt11InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
39925 if(!isWasmInitialized) {
39926 throw new Error("initializeWasm() must be awaited first!");
39928 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_secret(this_arg);
39929 return nativeResponseValue;
39931 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39933 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
39934 if(!isWasmInitialized) {
39935 throw new Error("initializeWasm() must be awaited first!");
39937 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
39938 return nativeResponseValue;
39940 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39942 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
39943 if(!isWasmInitialized) {
39944 throw new Error("initializeWasm() must be awaited first!");
39946 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
39947 return nativeResponseValue;
39949 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39951 export function Bolt11InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
39952 if(!isWasmInitialized) {
39953 throw new Error("initializeWasm() must be awaited first!");
39955 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_secret(this_arg);
39956 return nativeResponseValue;
39958 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39960 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
39961 if(!isWasmInitialized) {
39962 throw new Error("initializeWasm() must be awaited first!");
39964 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
39965 // debug statements here
39967 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39969 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
39970 if(!isWasmInitialized) {
39971 throw new Error("initializeWasm() must be awaited first!");
39973 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
39974 // debug statements here
39976 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39978 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
39979 if(!isWasmInitialized) {
39980 throw new Error("initializeWasm() must be awaited first!");
39982 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
39983 return nativeResponseValue;
39985 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39987 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
39988 if(!isWasmInitialized) {
39989 throw new Error("initializeWasm() must be awaited first!");
39991 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
39992 // debug statements here
39994 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39996 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
39997 if(!isWasmInitialized) {
39998 throw new Error("initializeWasm() must be awaited first!");
40000 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
40001 // debug statements here
40003 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40005 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40006 if(!isWasmInitialized) {
40007 throw new Error("initializeWasm() must be awaited first!");
40009 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
40010 return nativeResponseValue;
40012 // void Bolt11InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40014 export function Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
40015 if(!isWasmInitialized) {
40016 throw new Error("initializeWasm() must be awaited first!");
40018 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg);
40019 // debug statements here
40021 // void Bolt11InvoiceFeatures_set_basic_mpp_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40023 export function Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
40024 if(!isWasmInitialized) {
40025 throw new Error("initializeWasm() must be awaited first!");
40027 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg);
40028 // debug statements here
40030 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40032 export function Bolt11InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40033 if(!isWasmInitialized) {
40034 throw new Error("initializeWasm() must be awaited first!");
40036 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_basic_mpp(this_arg);
40037 return nativeResponseValue;
40039 // void Bolt12InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40041 export function Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
40042 if(!isWasmInitialized) {
40043 throw new Error("initializeWasm() must be awaited first!");
40045 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg);
40046 // debug statements here
40048 // void Bolt12InvoiceFeatures_set_basic_mpp_required(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40050 export function Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
40051 if(!isWasmInitialized) {
40052 throw new Error("initializeWasm() must be awaited first!");
40054 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg);
40055 // debug statements here
40057 // MUST_USE_RES bool Bolt12InvoiceFeatures_supports_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40059 export function Bolt12InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40060 if(!isWasmInitialized) {
40061 throw new Error("initializeWasm() must be awaited first!");
40063 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_supports_basic_mpp(this_arg);
40064 return nativeResponseValue;
40066 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40068 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40069 if(!isWasmInitialized) {
40070 throw new Error("initializeWasm() must be awaited first!");
40072 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
40073 return nativeResponseValue;
40075 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40077 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40078 if(!isWasmInitialized) {
40079 throw new Error("initializeWasm() must be awaited first!");
40081 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
40082 return nativeResponseValue;
40084 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40086 export function Bolt11InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40087 if(!isWasmInitialized) {
40088 throw new Error("initializeWasm() must be awaited first!");
40090 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_basic_mpp(this_arg);
40091 return nativeResponseValue;
40093 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40095 export function Bolt12InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40096 if(!isWasmInitialized) {
40097 throw new Error("initializeWasm() must be awaited first!");
40099 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_basic_mpp(this_arg);
40100 return nativeResponseValue;
40102 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40104 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
40105 if(!isWasmInitialized) {
40106 throw new Error("initializeWasm() must be awaited first!");
40108 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
40109 // debug statements here
40111 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40113 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
40114 if(!isWasmInitialized) {
40115 throw new Error("initializeWasm() must be awaited first!");
40117 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
40118 // debug statements here
40120 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40122 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
40123 if(!isWasmInitialized) {
40124 throw new Error("initializeWasm() must be awaited first!");
40126 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
40127 return nativeResponseValue;
40129 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40131 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
40132 if(!isWasmInitialized) {
40133 throw new Error("initializeWasm() must be awaited first!");
40135 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
40136 // debug statements here
40138 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40140 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
40141 if(!isWasmInitialized) {
40142 throw new Error("initializeWasm() must be awaited first!");
40144 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
40145 // debug statements here
40147 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40149 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
40150 if(!isWasmInitialized) {
40151 throw new Error("initializeWasm() must be awaited first!");
40153 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
40154 return nativeResponseValue;
40156 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40158 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
40159 if(!isWasmInitialized) {
40160 throw new Error("initializeWasm() must be awaited first!");
40162 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
40163 return nativeResponseValue;
40165 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40167 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
40168 if(!isWasmInitialized) {
40169 throw new Error("initializeWasm() must be awaited first!");
40171 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
40172 return nativeResponseValue;
40174 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40176 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
40177 if(!isWasmInitialized) {
40178 throw new Error("initializeWasm() must be awaited first!");
40180 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
40181 // debug statements here
40183 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40185 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
40186 if(!isWasmInitialized) {
40187 throw new Error("initializeWasm() must be awaited first!");
40189 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
40190 // debug statements here
40192 // MUST_USE_RES bool InitFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40194 export function InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40195 if(!isWasmInitialized) {
40196 throw new Error("initializeWasm() must be awaited first!");
40198 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
40199 return nativeResponseValue;
40201 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40203 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
40204 if(!isWasmInitialized) {
40205 throw new Error("initializeWasm() must be awaited first!");
40207 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
40208 // debug statements here
40210 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40212 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
40213 if(!isWasmInitialized) {
40214 throw new Error("initializeWasm() must be awaited first!");
40216 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
40217 // debug statements here
40219 // MUST_USE_RES bool NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40221 export function NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40222 if(!isWasmInitialized) {
40223 throw new Error("initializeWasm() must be awaited first!");
40225 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
40226 return nativeResponseValue;
40228 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40230 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
40231 if(!isWasmInitialized) {
40232 throw new Error("initializeWasm() must be awaited first!");
40234 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
40235 // debug statements here
40237 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40239 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
40240 if(!isWasmInitialized) {
40241 throw new Error("initializeWasm() must be awaited first!");
40243 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
40244 // debug statements here
40246 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40248 export function ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40249 if(!isWasmInitialized) {
40250 throw new Error("initializeWasm() must be awaited first!");
40252 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
40253 return nativeResponseValue;
40255 // MUST_USE_RES bool InitFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40257 export function InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40258 if(!isWasmInitialized) {
40259 throw new Error("initializeWasm() must be awaited first!");
40261 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
40262 return nativeResponseValue;
40264 // MUST_USE_RES bool NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40266 export function NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40267 if(!isWasmInitialized) {
40268 throw new Error("initializeWasm() must be awaited first!");
40270 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
40271 return nativeResponseValue;
40273 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40275 export function ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40276 if(!isWasmInitialized) {
40277 throw new Error("initializeWasm() must be awaited first!");
40279 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
40280 return nativeResponseValue;
40282 // void InitFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40284 export function InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
40285 if(!isWasmInitialized) {
40286 throw new Error("initializeWasm() must be awaited first!");
40288 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
40289 // debug statements here
40291 // void InitFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40293 export function InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
40294 if(!isWasmInitialized) {
40295 throw new Error("initializeWasm() must be awaited first!");
40297 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
40298 // debug statements here
40300 // MUST_USE_RES bool InitFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40302 export function InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40303 if(!isWasmInitialized) {
40304 throw new Error("initializeWasm() must be awaited first!");
40306 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
40307 return nativeResponseValue;
40309 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40311 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
40312 if(!isWasmInitialized) {
40313 throw new Error("initializeWasm() must be awaited first!");
40315 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
40316 // debug statements here
40318 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40320 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
40321 if(!isWasmInitialized) {
40322 throw new Error("initializeWasm() must be awaited first!");
40324 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
40325 // debug statements here
40327 // MUST_USE_RES bool NodeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40329 export function NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40330 if(!isWasmInitialized) {
40331 throw new Error("initializeWasm() must be awaited first!");
40333 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
40334 return nativeResponseValue;
40336 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40338 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
40339 if(!isWasmInitialized) {
40340 throw new Error("initializeWasm() must be awaited first!");
40342 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
40343 // debug statements here
40345 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40347 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
40348 if(!isWasmInitialized) {
40349 throw new Error("initializeWasm() must be awaited first!");
40351 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
40352 // debug statements here
40354 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40356 export function ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40357 if(!isWasmInitialized) {
40358 throw new Error("initializeWasm() must be awaited first!");
40360 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
40361 return nativeResponseValue;
40363 // MUST_USE_RES bool InitFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40365 export function InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40366 if(!isWasmInitialized) {
40367 throw new Error("initializeWasm() must be awaited first!");
40369 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
40370 return nativeResponseValue;
40372 // MUST_USE_RES bool NodeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40374 export function NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40375 if(!isWasmInitialized) {
40376 throw new Error("initializeWasm() must be awaited first!");
40378 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
40379 return nativeResponseValue;
40381 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40383 export function ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40384 if(!isWasmInitialized) {
40385 throw new Error("initializeWasm() must be awaited first!");
40387 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
40388 return nativeResponseValue;
40390 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40392 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
40393 if(!isWasmInitialized) {
40394 throw new Error("initializeWasm() must be awaited first!");
40396 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
40397 // debug statements here
40399 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40401 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
40402 if(!isWasmInitialized) {
40403 throw new Error("initializeWasm() must be awaited first!");
40405 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
40406 // debug statements here
40408 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40410 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
40411 if(!isWasmInitialized) {
40412 throw new Error("initializeWasm() must be awaited first!");
40414 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
40415 return nativeResponseValue;
40417 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40419 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
40420 if(!isWasmInitialized) {
40421 throw new Error("initializeWasm() must be awaited first!");
40423 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
40424 // debug statements here
40426 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40428 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
40429 if(!isWasmInitialized) {
40430 throw new Error("initializeWasm() must be awaited first!");
40432 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
40433 // debug statements here
40435 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40437 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
40438 if(!isWasmInitialized) {
40439 throw new Error("initializeWasm() must be awaited first!");
40441 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
40442 return nativeResponseValue;
40444 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40446 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
40447 if(!isWasmInitialized) {
40448 throw new Error("initializeWasm() must be awaited first!");
40450 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
40451 return nativeResponseValue;
40453 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40455 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
40456 if(!isWasmInitialized) {
40457 throw new Error("initializeWasm() must be awaited first!");
40459 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
40460 return nativeResponseValue;
40462 // void InitFeatures_set_taproot_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40464 export function InitFeatures_set_taproot_optional(this_arg: bigint): void {
40465 if(!isWasmInitialized) {
40466 throw new Error("initializeWasm() must be awaited first!");
40468 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_optional(this_arg);
40469 // debug statements here
40471 // void InitFeatures_set_taproot_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40473 export function InitFeatures_set_taproot_required(this_arg: bigint): void {
40474 if(!isWasmInitialized) {
40475 throw new Error("initializeWasm() must be awaited first!");
40477 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_required(this_arg);
40478 // debug statements here
40480 // MUST_USE_RES bool InitFeatures_supports_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40482 export function InitFeatures_supports_taproot(this_arg: bigint): boolean {
40483 if(!isWasmInitialized) {
40484 throw new Error("initializeWasm() must be awaited first!");
40486 const nativeResponseValue = wasm.TS_InitFeatures_supports_taproot(this_arg);
40487 return nativeResponseValue;
40489 // void NodeFeatures_set_taproot_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40491 export function NodeFeatures_set_taproot_optional(this_arg: bigint): void {
40492 if(!isWasmInitialized) {
40493 throw new Error("initializeWasm() must be awaited first!");
40495 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_optional(this_arg);
40496 // debug statements here
40498 // void NodeFeatures_set_taproot_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40500 export function NodeFeatures_set_taproot_required(this_arg: bigint): void {
40501 if(!isWasmInitialized) {
40502 throw new Error("initializeWasm() must be awaited first!");
40504 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_required(this_arg);
40505 // debug statements here
40507 // MUST_USE_RES bool NodeFeatures_supports_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40509 export function NodeFeatures_supports_taproot(this_arg: bigint): boolean {
40510 if(!isWasmInitialized) {
40511 throw new Error("initializeWasm() must be awaited first!");
40513 const nativeResponseValue = wasm.TS_NodeFeatures_supports_taproot(this_arg);
40514 return nativeResponseValue;
40516 // void ChannelTypeFeatures_set_taproot_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40518 export function ChannelTypeFeatures_set_taproot_optional(this_arg: bigint): void {
40519 if(!isWasmInitialized) {
40520 throw new Error("initializeWasm() must be awaited first!");
40522 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_optional(this_arg);
40523 // debug statements here
40525 // void ChannelTypeFeatures_set_taproot_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40527 export function ChannelTypeFeatures_set_taproot_required(this_arg: bigint): void {
40528 if(!isWasmInitialized) {
40529 throw new Error("initializeWasm() must be awaited first!");
40531 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_required(this_arg);
40532 // debug statements here
40534 // MUST_USE_RES bool ChannelTypeFeatures_supports_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40536 export function ChannelTypeFeatures_supports_taproot(this_arg: bigint): boolean {
40537 if(!isWasmInitialized) {
40538 throw new Error("initializeWasm() must be awaited first!");
40540 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_taproot(this_arg);
40541 return nativeResponseValue;
40543 // MUST_USE_RES bool InitFeatures_requires_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40545 export function InitFeatures_requires_taproot(this_arg: bigint): boolean {
40546 if(!isWasmInitialized) {
40547 throw new Error("initializeWasm() must be awaited first!");
40549 const nativeResponseValue = wasm.TS_InitFeatures_requires_taproot(this_arg);
40550 return nativeResponseValue;
40552 // MUST_USE_RES bool NodeFeatures_requires_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40554 export function NodeFeatures_requires_taproot(this_arg: bigint): boolean {
40555 if(!isWasmInitialized) {
40556 throw new Error("initializeWasm() must be awaited first!");
40558 const nativeResponseValue = wasm.TS_NodeFeatures_requires_taproot(this_arg);
40559 return nativeResponseValue;
40561 // MUST_USE_RES bool ChannelTypeFeatures_requires_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40563 export function ChannelTypeFeatures_requires_taproot(this_arg: bigint): boolean {
40564 if(!isWasmInitialized) {
40565 throw new Error("initializeWasm() must be awaited first!");
40567 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_taproot(this_arg);
40568 return nativeResponseValue;
40570 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40572 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
40573 if(!isWasmInitialized) {
40574 throw new Error("initializeWasm() must be awaited first!");
40576 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
40577 // debug statements here
40579 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40581 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
40582 if(!isWasmInitialized) {
40583 throw new Error("initializeWasm() must be awaited first!");
40585 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
40586 // debug statements here
40588 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40590 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
40591 if(!isWasmInitialized) {
40592 throw new Error("initializeWasm() must be awaited first!");
40594 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
40595 return nativeResponseValue;
40597 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40599 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
40600 if(!isWasmInitialized) {
40601 throw new Error("initializeWasm() must be awaited first!");
40603 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
40604 // debug statements here
40606 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40608 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
40609 if(!isWasmInitialized) {
40610 throw new Error("initializeWasm() must be awaited first!");
40612 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
40613 // debug statements here
40615 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40617 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
40618 if(!isWasmInitialized) {
40619 throw new Error("initializeWasm() must be awaited first!");
40621 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
40622 return nativeResponseValue;
40624 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40626 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
40627 if(!isWasmInitialized) {
40628 throw new Error("initializeWasm() must be awaited first!");
40630 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
40631 return nativeResponseValue;
40633 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40635 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
40636 if(!isWasmInitialized) {
40637 throw new Error("initializeWasm() must be awaited first!");
40639 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
40640 return nativeResponseValue;
40642 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40644 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
40645 if(!isWasmInitialized) {
40646 throw new Error("initializeWasm() must be awaited first!");
40648 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
40649 // debug statements here
40651 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40653 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
40654 if(!isWasmInitialized) {
40655 throw new Error("initializeWasm() must be awaited first!");
40657 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
40658 // debug statements here
40660 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40662 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
40663 if(!isWasmInitialized) {
40664 throw new Error("initializeWasm() must be awaited first!");
40666 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
40667 return nativeResponseValue;
40669 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40671 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
40672 if(!isWasmInitialized) {
40673 throw new Error("initializeWasm() must be awaited first!");
40675 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
40676 // debug statements here
40678 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40680 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
40681 if(!isWasmInitialized) {
40682 throw new Error("initializeWasm() must be awaited first!");
40684 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
40685 // debug statements here
40687 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40689 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
40690 if(!isWasmInitialized) {
40691 throw new Error("initializeWasm() must be awaited first!");
40693 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
40694 return nativeResponseValue;
40696 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40698 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
40699 if(!isWasmInitialized) {
40700 throw new Error("initializeWasm() must be awaited first!");
40702 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
40703 return nativeResponseValue;
40705 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40707 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
40708 if(!isWasmInitialized) {
40709 throw new Error("initializeWasm() must be awaited first!");
40711 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
40712 return nativeResponseValue;
40714 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40716 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
40717 if(!isWasmInitialized) {
40718 throw new Error("initializeWasm() must be awaited first!");
40720 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
40721 // debug statements here
40723 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40725 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
40726 if(!isWasmInitialized) {
40727 throw new Error("initializeWasm() must be awaited first!");
40729 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
40730 // debug statements here
40732 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40734 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
40735 if(!isWasmInitialized) {
40736 throw new Error("initializeWasm() must be awaited first!");
40738 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
40739 return nativeResponseValue;
40741 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40743 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
40744 if(!isWasmInitialized) {
40745 throw new Error("initializeWasm() must be awaited first!");
40747 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
40748 // debug statements here
40750 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40752 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
40753 if(!isWasmInitialized) {
40754 throw new Error("initializeWasm() must be awaited first!");
40756 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
40757 // debug statements here
40759 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40761 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
40762 if(!isWasmInitialized) {
40763 throw new Error("initializeWasm() must be awaited first!");
40765 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
40766 return nativeResponseValue;
40768 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40770 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
40771 if(!isWasmInitialized) {
40772 throw new Error("initializeWasm() must be awaited first!");
40774 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
40775 // debug statements here
40777 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40779 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
40780 if(!isWasmInitialized) {
40781 throw new Error("initializeWasm() must be awaited first!");
40783 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
40784 // debug statements here
40786 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40788 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
40789 if(!isWasmInitialized) {
40790 throw new Error("initializeWasm() must be awaited first!");
40792 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
40793 return nativeResponseValue;
40795 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40797 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
40798 if(!isWasmInitialized) {
40799 throw new Error("initializeWasm() must be awaited first!");
40801 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
40802 return nativeResponseValue;
40804 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40806 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
40807 if(!isWasmInitialized) {
40808 throw new Error("initializeWasm() must be awaited first!");
40810 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
40811 return nativeResponseValue;
40813 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40815 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
40816 if(!isWasmInitialized) {
40817 throw new Error("initializeWasm() must be awaited first!");
40819 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
40820 return nativeResponseValue;
40822 // void Bolt11InvoiceFeatures_set_payment_metadata_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40824 export function Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg: bigint): void {
40825 if(!isWasmInitialized) {
40826 throw new Error("initializeWasm() must be awaited first!");
40828 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg);
40829 // debug statements here
40831 // void Bolt11InvoiceFeatures_set_payment_metadata_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40833 export function Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg: bigint): void {
40834 if(!isWasmInitialized) {
40835 throw new Error("initializeWasm() must be awaited first!");
40837 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg);
40838 // debug statements here
40840 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40842 export function Bolt11InvoiceFeatures_supports_payment_metadata(this_arg: bigint): boolean {
40843 if(!isWasmInitialized) {
40844 throw new Error("initializeWasm() must be awaited first!");
40846 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_metadata(this_arg);
40847 return nativeResponseValue;
40849 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40851 export function Bolt11InvoiceFeatures_requires_payment_metadata(this_arg: bigint): boolean {
40852 if(!isWasmInitialized) {
40853 throw new Error("initializeWasm() must be awaited first!");
40855 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_metadata(this_arg);
40856 return nativeResponseValue;
40858 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40860 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
40861 if(!isWasmInitialized) {
40862 throw new Error("initializeWasm() must be awaited first!");
40864 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
40865 // debug statements here
40867 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40869 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
40870 if(!isWasmInitialized) {
40871 throw new Error("initializeWasm() must be awaited first!");
40873 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
40874 // debug statements here
40876 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40878 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
40879 if(!isWasmInitialized) {
40880 throw new Error("initializeWasm() must be awaited first!");
40882 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
40883 return nativeResponseValue;
40885 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40887 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
40888 if(!isWasmInitialized) {
40889 throw new Error("initializeWasm() must be awaited first!");
40891 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
40892 // debug statements here
40894 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40896 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
40897 if(!isWasmInitialized) {
40898 throw new Error("initializeWasm() must be awaited first!");
40900 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
40901 // debug statements here
40903 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40905 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
40906 if(!isWasmInitialized) {
40907 throw new Error("initializeWasm() must be awaited first!");
40909 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
40910 return nativeResponseValue;
40912 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40914 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
40915 if(!isWasmInitialized) {
40916 throw new Error("initializeWasm() must be awaited first!");
40918 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
40919 // debug statements here
40921 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40923 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
40924 if(!isWasmInitialized) {
40925 throw new Error("initializeWasm() must be awaited first!");
40927 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
40928 // debug statements here
40930 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40932 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
40933 if(!isWasmInitialized) {
40934 throw new Error("initializeWasm() must be awaited first!");
40936 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
40937 return nativeResponseValue;
40939 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40941 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
40942 if(!isWasmInitialized) {
40943 throw new Error("initializeWasm() must be awaited first!");
40945 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
40946 return nativeResponseValue;
40948 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40950 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
40951 if(!isWasmInitialized) {
40952 throw new Error("initializeWasm() must be awaited first!");
40954 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
40955 return nativeResponseValue;
40957 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40959 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
40960 if(!isWasmInitialized) {
40961 throw new Error("initializeWasm() must be awaited first!");
40963 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
40964 return nativeResponseValue;
40966 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40968 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
40969 if(!isWasmInitialized) {
40970 throw new Error("initializeWasm() must be awaited first!");
40972 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
40973 // debug statements here
40975 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40977 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
40978 if(!isWasmInitialized) {
40979 throw new Error("initializeWasm() must be awaited first!");
40981 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
40982 // debug statements here
40984 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40986 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
40987 if(!isWasmInitialized) {
40988 throw new Error("initializeWasm() must be awaited first!");
40990 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
40991 return nativeResponseValue;
40993 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40995 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
40996 if(!isWasmInitialized) {
40997 throw new Error("initializeWasm() must be awaited first!");
40999 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
41000 return nativeResponseValue;
41002 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
41004 export function ShutdownScript_free(this_obj: bigint): void {
41005 if(!isWasmInitialized) {
41006 throw new Error("initializeWasm() must be awaited first!");
41008 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
41009 // debug statements here
41011 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
41013 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
41014 if(!isWasmInitialized) {
41015 throw new Error("initializeWasm() must be awaited first!");
41017 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
41018 return nativeResponseValue;
41020 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
41022 export function ShutdownScript_clone(orig: bigint): bigint {
41023 if(!isWasmInitialized) {
41024 throw new Error("initializeWasm() must be awaited first!");
41026 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
41027 return nativeResponseValue;
41029 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
41031 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
41032 if(!isWasmInitialized) {
41033 throw new Error("initializeWasm() must be awaited first!");
41035 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
41036 return nativeResponseValue;
41038 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
41040 export function InvalidShutdownScript_free(this_obj: bigint): void {
41041 if(!isWasmInitialized) {
41042 throw new Error("initializeWasm() must be awaited first!");
41044 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
41045 // debug statements here
41047 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
41049 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
41050 if(!isWasmInitialized) {
41051 throw new Error("initializeWasm() must be awaited first!");
41053 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
41054 return nativeResponseValue;
41056 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
41058 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
41059 if(!isWasmInitialized) {
41060 throw new Error("initializeWasm() must be awaited first!");
41062 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
41063 // debug statements here
41065 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
41067 export function InvalidShutdownScript_new(script_arg: number): bigint {
41068 if(!isWasmInitialized) {
41069 throw new Error("initializeWasm() must be awaited first!");
41071 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
41072 return nativeResponseValue;
41074 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
41076 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
41077 if(!isWasmInitialized) {
41078 throw new Error("initializeWasm() must be awaited first!");
41080 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
41081 return nativeResponseValue;
41083 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
41085 export function InvalidShutdownScript_clone(orig: bigint): bigint {
41086 if(!isWasmInitialized) {
41087 throw new Error("initializeWasm() must be awaited first!");
41089 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
41090 return nativeResponseValue;
41092 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
41094 export function ShutdownScript_write(obj: bigint): number {
41095 if(!isWasmInitialized) {
41096 throw new Error("initializeWasm() must be awaited first!");
41098 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
41099 return nativeResponseValue;
41101 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
41103 export function ShutdownScript_read(ser: number): bigint {
41104 if(!isWasmInitialized) {
41105 throw new Error("initializeWasm() must be awaited first!");
41107 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
41108 return nativeResponseValue;
41110 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
41112 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
41113 if(!isWasmInitialized) {
41114 throw new Error("initializeWasm() must be awaited first!");
41116 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
41117 return nativeResponseValue;
41119 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
41121 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
41122 if(!isWasmInitialized) {
41123 throw new Error("initializeWasm() must be awaited first!");
41125 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
41126 return nativeResponseValue;
41128 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
41130 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
41131 if(!isWasmInitialized) {
41132 throw new Error("initializeWasm() must be awaited first!");
41134 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
41135 return nativeResponseValue;
41137 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
41139 export function ShutdownScript_into_inner(this_arg: bigint): number {
41140 if(!isWasmInitialized) {
41141 throw new Error("initializeWasm() must be awaited first!");
41143 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
41144 return nativeResponseValue;
41146 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
41148 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
41149 if(!isWasmInitialized) {
41150 throw new Error("initializeWasm() must be awaited first!");
41152 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
41153 return nativeResponseValue;
41155 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
41157 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
41158 if(!isWasmInitialized) {
41159 throw new Error("initializeWasm() must be awaited first!");
41161 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
41162 return nativeResponseValue;
41164 // void Retry_free(struct LDKRetry this_ptr);
41166 export function Retry_free(this_ptr: bigint): void {
41167 if(!isWasmInitialized) {
41168 throw new Error("initializeWasm() must be awaited first!");
41170 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
41171 // debug statements here
41173 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
41175 export function Retry_clone_ptr(arg: bigint): bigint {
41176 if(!isWasmInitialized) {
41177 throw new Error("initializeWasm() must be awaited first!");
41179 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
41180 return nativeResponseValue;
41182 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
41184 export function Retry_clone(orig: bigint): bigint {
41185 if(!isWasmInitialized) {
41186 throw new Error("initializeWasm() must be awaited first!");
41188 const nativeResponseValue = wasm.TS_Retry_clone(orig);
41189 return nativeResponseValue;
41191 // struct LDKRetry Retry_attempts(uint32_t a);
41193 export function Retry_attempts(a: number): bigint {
41194 if(!isWasmInitialized) {
41195 throw new Error("initializeWasm() must be awaited first!");
41197 const nativeResponseValue = wasm.TS_Retry_attempts(a);
41198 return nativeResponseValue;
41200 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
41202 export function Retry_eq(a: bigint, b: bigint): boolean {
41203 if(!isWasmInitialized) {
41204 throw new Error("initializeWasm() must be awaited first!");
41206 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
41207 return nativeResponseValue;
41209 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
41211 export function Retry_hash(o: bigint): bigint {
41212 if(!isWasmInitialized) {
41213 throw new Error("initializeWasm() must be awaited first!");
41215 const nativeResponseValue = wasm.TS_Retry_hash(o);
41216 return nativeResponseValue;
41218 // struct LDKCVec_u8Z Retry_write(const struct LDKRetry *NONNULL_PTR obj);
41220 export function Retry_write(obj: bigint): number {
41221 if(!isWasmInitialized) {
41222 throw new Error("initializeWasm() must be awaited first!");
41224 const nativeResponseValue = wasm.TS_Retry_write(obj);
41225 return nativeResponseValue;
41227 // struct LDKCResult_RetryDecodeErrorZ Retry_read(struct LDKu8slice ser);
41229 export function Retry_read(ser: number): bigint {
41230 if(!isWasmInitialized) {
41231 throw new Error("initializeWasm() must be awaited first!");
41233 const nativeResponseValue = wasm.TS_Retry_read(ser);
41234 return nativeResponseValue;
41236 // enum LDKRetryableSendFailure RetryableSendFailure_clone(const enum LDKRetryableSendFailure *NONNULL_PTR orig);
41238 export function RetryableSendFailure_clone(orig: bigint): RetryableSendFailure {
41239 if(!isWasmInitialized) {
41240 throw new Error("initializeWasm() must be awaited first!");
41242 const nativeResponseValue = wasm.TS_RetryableSendFailure_clone(orig);
41243 return nativeResponseValue;
41245 // enum LDKRetryableSendFailure RetryableSendFailure_payment_expired(void);
41247 export function RetryableSendFailure_payment_expired(): RetryableSendFailure {
41248 if(!isWasmInitialized) {
41249 throw new Error("initializeWasm() must be awaited first!");
41251 const nativeResponseValue = wasm.TS_RetryableSendFailure_payment_expired();
41252 return nativeResponseValue;
41254 // enum LDKRetryableSendFailure RetryableSendFailure_route_not_found(void);
41256 export function RetryableSendFailure_route_not_found(): RetryableSendFailure {
41257 if(!isWasmInitialized) {
41258 throw new Error("initializeWasm() must be awaited first!");
41260 const nativeResponseValue = wasm.TS_RetryableSendFailure_route_not_found();
41261 return nativeResponseValue;
41263 // enum LDKRetryableSendFailure RetryableSendFailure_duplicate_payment(void);
41265 export function RetryableSendFailure_duplicate_payment(): RetryableSendFailure {
41266 if(!isWasmInitialized) {
41267 throw new Error("initializeWasm() must be awaited first!");
41269 const nativeResponseValue = wasm.TS_RetryableSendFailure_duplicate_payment();
41270 return nativeResponseValue;
41272 // bool RetryableSendFailure_eq(const enum LDKRetryableSendFailure *NONNULL_PTR a, const enum LDKRetryableSendFailure *NONNULL_PTR b);
41274 export function RetryableSendFailure_eq(a: bigint, b: bigint): boolean {
41275 if(!isWasmInitialized) {
41276 throw new Error("initializeWasm() must be awaited first!");
41278 const nativeResponseValue = wasm.TS_RetryableSendFailure_eq(a, b);
41279 return nativeResponseValue;
41281 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
41283 export function PaymentSendFailure_free(this_ptr: bigint): void {
41284 if(!isWasmInitialized) {
41285 throw new Error("initializeWasm() must be awaited first!");
41287 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
41288 // debug statements here
41290 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
41292 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
41293 if(!isWasmInitialized) {
41294 throw new Error("initializeWasm() must be awaited first!");
41296 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
41297 return nativeResponseValue;
41299 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
41301 export function PaymentSendFailure_clone(orig: bigint): bigint {
41302 if(!isWasmInitialized) {
41303 throw new Error("initializeWasm() must be awaited first!");
41305 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
41306 return nativeResponseValue;
41308 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
41310 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
41311 if(!isWasmInitialized) {
41312 throw new Error("initializeWasm() must be awaited first!");
41314 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
41315 return nativeResponseValue;
41317 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
41319 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
41320 if(!isWasmInitialized) {
41321 throw new Error("initializeWasm() must be awaited first!");
41323 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
41324 return nativeResponseValue;
41326 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
41328 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
41329 if(!isWasmInitialized) {
41330 throw new Error("initializeWasm() must be awaited first!");
41332 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
41333 return nativeResponseValue;
41335 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
41337 export function PaymentSendFailure_duplicate_payment(): bigint {
41338 if(!isWasmInitialized) {
41339 throw new Error("initializeWasm() must be awaited first!");
41341 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
41342 return nativeResponseValue;
41344 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
41346 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
41347 if(!isWasmInitialized) {
41348 throw new Error("initializeWasm() must be awaited first!");
41350 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
41351 return nativeResponseValue;
41353 // bool PaymentSendFailure_eq(const struct LDKPaymentSendFailure *NONNULL_PTR a, const struct LDKPaymentSendFailure *NONNULL_PTR b);
41355 export function PaymentSendFailure_eq(a: bigint, b: bigint): boolean {
41356 if(!isWasmInitialized) {
41357 throw new Error("initializeWasm() must be awaited first!");
41359 const nativeResponseValue = wasm.TS_PaymentSendFailure_eq(a, b);
41360 return nativeResponseValue;
41362 // void ProbeSendFailure_free(struct LDKProbeSendFailure this_ptr);
41364 export function ProbeSendFailure_free(this_ptr: bigint): void {
41365 if(!isWasmInitialized) {
41366 throw new Error("initializeWasm() must be awaited first!");
41368 const nativeResponseValue = wasm.TS_ProbeSendFailure_free(this_ptr);
41369 // debug statements here
41371 // uint64_t ProbeSendFailure_clone_ptr(LDKProbeSendFailure *NONNULL_PTR arg);
41373 export function ProbeSendFailure_clone_ptr(arg: bigint): bigint {
41374 if(!isWasmInitialized) {
41375 throw new Error("initializeWasm() must be awaited first!");
41377 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone_ptr(arg);
41378 return nativeResponseValue;
41380 // struct LDKProbeSendFailure ProbeSendFailure_clone(const struct LDKProbeSendFailure *NONNULL_PTR orig);
41382 export function ProbeSendFailure_clone(orig: bigint): bigint {
41383 if(!isWasmInitialized) {
41384 throw new Error("initializeWasm() must be awaited first!");
41386 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone(orig);
41387 return nativeResponseValue;
41389 // struct LDKProbeSendFailure ProbeSendFailure_route_not_found(void);
41391 export function ProbeSendFailure_route_not_found(): bigint {
41392 if(!isWasmInitialized) {
41393 throw new Error("initializeWasm() must be awaited first!");
41395 const nativeResponseValue = wasm.TS_ProbeSendFailure_route_not_found();
41396 return nativeResponseValue;
41398 // struct LDKProbeSendFailure ProbeSendFailure_sending_failed(struct LDKPaymentSendFailure a);
41400 export function ProbeSendFailure_sending_failed(a: bigint): bigint {
41401 if(!isWasmInitialized) {
41402 throw new Error("initializeWasm() must be awaited first!");
41404 const nativeResponseValue = wasm.TS_ProbeSendFailure_sending_failed(a);
41405 return nativeResponseValue;
41407 // bool ProbeSendFailure_eq(const struct LDKProbeSendFailure *NONNULL_PTR a, const struct LDKProbeSendFailure *NONNULL_PTR b);
41409 export function ProbeSendFailure_eq(a: bigint, b: bigint): boolean {
41410 if(!isWasmInitialized) {
41411 throw new Error("initializeWasm() must be awaited first!");
41413 const nativeResponseValue = wasm.TS_ProbeSendFailure_eq(a, b);
41414 return nativeResponseValue;
41416 // void RecipientOnionFields_free(struct LDKRecipientOnionFields this_obj);
41418 export function RecipientOnionFields_free(this_obj: bigint): void {
41419 if(!isWasmInitialized) {
41420 throw new Error("initializeWasm() must be awaited first!");
41422 const nativeResponseValue = wasm.TS_RecipientOnionFields_free(this_obj);
41423 // debug statements here
41425 // struct LDKCOption_ThirtyTwoBytesZ RecipientOnionFields_get_payment_secret(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
41427 export function RecipientOnionFields_get_payment_secret(this_ptr: bigint): bigint {
41428 if(!isWasmInitialized) {
41429 throw new Error("initializeWasm() must be awaited first!");
41431 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_secret(this_ptr);
41432 return nativeResponseValue;
41434 // void RecipientOnionFields_set_payment_secret(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
41436 export function RecipientOnionFields_set_payment_secret(this_ptr: bigint, val: bigint): void {
41437 if(!isWasmInitialized) {
41438 throw new Error("initializeWasm() must be awaited first!");
41440 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_secret(this_ptr, val);
41441 // debug statements here
41443 // struct LDKCOption_CVec_u8ZZ RecipientOnionFields_get_payment_metadata(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
41445 export function RecipientOnionFields_get_payment_metadata(this_ptr: bigint): bigint {
41446 if(!isWasmInitialized) {
41447 throw new Error("initializeWasm() must be awaited first!");
41449 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_metadata(this_ptr);
41450 return nativeResponseValue;
41452 // void RecipientOnionFields_set_payment_metadata(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
41454 export function RecipientOnionFields_set_payment_metadata(this_ptr: bigint, val: bigint): void {
41455 if(!isWasmInitialized) {
41456 throw new Error("initializeWasm() must be awaited first!");
41458 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_metadata(this_ptr, val);
41459 // debug statements here
41461 // uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg);
41463 export function RecipientOnionFields_clone_ptr(arg: bigint): bigint {
41464 if(!isWasmInitialized) {
41465 throw new Error("initializeWasm() must be awaited first!");
41467 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone_ptr(arg);
41468 return nativeResponseValue;
41470 // struct LDKRecipientOnionFields RecipientOnionFields_clone(const struct LDKRecipientOnionFields *NONNULL_PTR orig);
41472 export function RecipientOnionFields_clone(orig: bigint): bigint {
41473 if(!isWasmInitialized) {
41474 throw new Error("initializeWasm() must be awaited first!");
41476 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone(orig);
41477 return nativeResponseValue;
41479 // bool RecipientOnionFields_eq(const struct LDKRecipientOnionFields *NONNULL_PTR a, const struct LDKRecipientOnionFields *NONNULL_PTR b);
41481 export function RecipientOnionFields_eq(a: bigint, b: bigint): boolean {
41482 if(!isWasmInitialized) {
41483 throw new Error("initializeWasm() must be awaited first!");
41485 const nativeResponseValue = wasm.TS_RecipientOnionFields_eq(a, b);
41486 return nativeResponseValue;
41488 // struct LDKCVec_u8Z RecipientOnionFields_write(const struct LDKRecipientOnionFields *NONNULL_PTR obj);
41490 export function RecipientOnionFields_write(obj: bigint): number {
41491 if(!isWasmInitialized) {
41492 throw new Error("initializeWasm() must be awaited first!");
41494 const nativeResponseValue = wasm.TS_RecipientOnionFields_write(obj);
41495 return nativeResponseValue;
41497 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ RecipientOnionFields_read(struct LDKu8slice ser);
41499 export function RecipientOnionFields_read(ser: number): bigint {
41500 if(!isWasmInitialized) {
41501 throw new Error("initializeWasm() must be awaited first!");
41503 const nativeResponseValue = wasm.TS_RecipientOnionFields_read(ser);
41504 return nativeResponseValue;
41506 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_secret_only(struct LDKThirtyTwoBytes payment_secret);
41508 export function RecipientOnionFields_secret_only(payment_secret: number): bigint {
41509 if(!isWasmInitialized) {
41510 throw new Error("initializeWasm() must be awaited first!");
41512 const nativeResponseValue = wasm.TS_RecipientOnionFields_secret_only(payment_secret);
41513 return nativeResponseValue;
41515 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_spontaneous_empty(void);
41517 export function RecipientOnionFields_spontaneous_empty(): bigint {
41518 if(!isWasmInitialized) {
41519 throw new Error("initializeWasm() must be awaited first!");
41521 const nativeResponseValue = wasm.TS_RecipientOnionFields_spontaneous_empty();
41522 return nativeResponseValue;
41524 // MUST_USE_RES struct LDKCResult_RecipientOnionFieldsNoneZ RecipientOnionFields_with_custom_tlvs(struct LDKRecipientOnionFields this_arg, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs);
41526 export function RecipientOnionFields_with_custom_tlvs(this_arg: bigint, custom_tlvs: number): bigint {
41527 if(!isWasmInitialized) {
41528 throw new Error("initializeWasm() must be awaited first!");
41530 const nativeResponseValue = wasm.TS_RecipientOnionFields_with_custom_tlvs(this_arg, custom_tlvs);
41531 return nativeResponseValue;
41533 // MUST_USE_RES struct LDKCVec_C2Tuple_u64CVec_u8ZZZ RecipientOnionFields_custom_tlvs(const struct LDKRecipientOnionFields *NONNULL_PTR this_arg);
41535 export function RecipientOnionFields_custom_tlvs(this_arg: bigint): number {
41536 if(!isWasmInitialized) {
41537 throw new Error("initializeWasm() must be awaited first!");
41539 const nativeResponseValue = wasm.TS_RecipientOnionFields_custom_tlvs(this_arg);
41540 return nativeResponseValue;
41542 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
41544 export function CustomMessageReader_free(this_ptr: bigint): void {
41545 if(!isWasmInitialized) {
41546 throw new Error("initializeWasm() must be awaited first!");
41548 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
41549 // debug statements here
41551 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
41553 export function Type_clone_ptr(arg: bigint): bigint {
41554 if(!isWasmInitialized) {
41555 throw new Error("initializeWasm() must be awaited first!");
41557 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
41558 return nativeResponseValue;
41560 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
41562 export function Type_clone(orig: bigint): bigint {
41563 if(!isWasmInitialized) {
41564 throw new Error("initializeWasm() must be awaited first!");
41566 const nativeResponseValue = wasm.TS_Type_clone(orig);
41567 return nativeResponseValue;
41569 // void Type_free(struct LDKType this_ptr);
41571 export function Type_free(this_ptr: bigint): void {
41572 if(!isWasmInitialized) {
41573 throw new Error("initializeWasm() must be awaited first!");
41575 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
41576 // debug statements here
41578 // void Offer_free(struct LDKOffer this_obj);
41580 export function Offer_free(this_obj: bigint): void {
41581 if(!isWasmInitialized) {
41582 throw new Error("initializeWasm() must be awaited first!");
41584 const nativeResponseValue = wasm.TS_Offer_free(this_obj);
41585 // debug statements here
41587 // uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
41589 export function Offer_clone_ptr(arg: bigint): bigint {
41590 if(!isWasmInitialized) {
41591 throw new Error("initializeWasm() must be awaited first!");
41593 const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
41594 return nativeResponseValue;
41596 // struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
41598 export function Offer_clone(orig: bigint): bigint {
41599 if(!isWasmInitialized) {
41600 throw new Error("initializeWasm() must be awaited first!");
41602 const nativeResponseValue = wasm.TS_Offer_clone(orig);
41603 return nativeResponseValue;
41605 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
41607 export function Offer_chains(this_arg: bigint): number {
41608 if(!isWasmInitialized) {
41609 throw new Error("initializeWasm() must be awaited first!");
41611 const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
41612 return nativeResponseValue;
41614 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
41616 export function Offer_metadata(this_arg: bigint): bigint {
41617 if(!isWasmInitialized) {
41618 throw new Error("initializeWasm() must be awaited first!");
41620 const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
41621 return nativeResponseValue;
41623 // MUST_USE_RES struct LDKAmount Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
41625 export function Offer_amount(this_arg: bigint): bigint {
41626 if(!isWasmInitialized) {
41627 throw new Error("initializeWasm() must be awaited first!");
41629 const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
41630 return nativeResponseValue;
41632 // MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
41634 export function Offer_description(this_arg: bigint): bigint {
41635 if(!isWasmInitialized) {
41636 throw new Error("initializeWasm() must be awaited first!");
41638 const nativeResponseValue = wasm.TS_Offer_description(this_arg);
41639 return nativeResponseValue;
41641 // MUST_USE_RES struct LDKOfferFeatures Offer_offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
41643 export function Offer_offer_features(this_arg: bigint): bigint {
41644 if(!isWasmInitialized) {
41645 throw new Error("initializeWasm() must be awaited first!");
41647 const nativeResponseValue = wasm.TS_Offer_offer_features(this_arg);
41648 return nativeResponseValue;
41650 // MUST_USE_RES struct LDKCOption_u64Z Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
41652 export function Offer_absolute_expiry(this_arg: bigint): bigint {
41653 if(!isWasmInitialized) {
41654 throw new Error("initializeWasm() must be awaited first!");
41656 const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
41657 return nativeResponseValue;
41659 // MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
41661 export function Offer_issuer(this_arg: bigint): bigint {
41662 if(!isWasmInitialized) {
41663 throw new Error("initializeWasm() must be awaited first!");
41665 const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
41666 return nativeResponseValue;
41668 // MUST_USE_RES struct LDKCVec_BlindedPathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
41670 export function Offer_paths(this_arg: bigint): number {
41671 if(!isWasmInitialized) {
41672 throw new Error("initializeWasm() must be awaited first!");
41674 const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
41675 return nativeResponseValue;
41677 // MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
41679 export function Offer_supported_quantity(this_arg: bigint): bigint {
41680 if(!isWasmInitialized) {
41681 throw new Error("initializeWasm() must be awaited first!");
41683 const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
41684 return nativeResponseValue;
41686 // MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
41688 export function Offer_signing_pubkey(this_arg: bigint): number {
41689 if(!isWasmInitialized) {
41690 throw new Error("initializeWasm() must be awaited first!");
41692 const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
41693 return nativeResponseValue;
41695 // MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
41697 export function Offer_supports_chain(this_arg: bigint, chain: number): boolean {
41698 if(!isWasmInitialized) {
41699 throw new Error("initializeWasm() must be awaited first!");
41701 const nativeResponseValue = wasm.TS_Offer_supports_chain(this_arg, chain);
41702 return nativeResponseValue;
41704 // MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
41706 export function Offer_is_valid_quantity(this_arg: bigint, quantity: bigint): boolean {
41707 if(!isWasmInitialized) {
41708 throw new Error("initializeWasm() must be awaited first!");
41710 const nativeResponseValue = wasm.TS_Offer_is_valid_quantity(this_arg, quantity);
41711 return nativeResponseValue;
41713 // MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
41715 export function Offer_expects_quantity(this_arg: bigint): boolean {
41716 if(!isWasmInitialized) {
41717 throw new Error("initializeWasm() must be awaited first!");
41719 const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
41720 return nativeResponseValue;
41722 // struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
41724 export function Offer_write(obj: bigint): number {
41725 if(!isWasmInitialized) {
41726 throw new Error("initializeWasm() must be awaited first!");
41728 const nativeResponseValue = wasm.TS_Offer_write(obj);
41729 return nativeResponseValue;
41731 // void Amount_free(struct LDKAmount this_obj);
41733 export function Amount_free(this_obj: bigint): void {
41734 if(!isWasmInitialized) {
41735 throw new Error("initializeWasm() must be awaited first!");
41737 const nativeResponseValue = wasm.TS_Amount_free(this_obj);
41738 // debug statements here
41740 // uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
41742 export function Amount_clone_ptr(arg: bigint): bigint {
41743 if(!isWasmInitialized) {
41744 throw new Error("initializeWasm() must be awaited first!");
41746 const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
41747 return nativeResponseValue;
41749 // struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
41751 export function Amount_clone(orig: bigint): bigint {
41752 if(!isWasmInitialized) {
41753 throw new Error("initializeWasm() must be awaited first!");
41755 const nativeResponseValue = wasm.TS_Amount_clone(orig);
41756 return nativeResponseValue;
41758 // void Quantity_free(struct LDKQuantity this_obj);
41760 export function Quantity_free(this_obj: bigint): void {
41761 if(!isWasmInitialized) {
41762 throw new Error("initializeWasm() must be awaited first!");
41764 const nativeResponseValue = wasm.TS_Quantity_free(this_obj);
41765 // debug statements here
41767 // uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
41769 export function Quantity_clone_ptr(arg: bigint): bigint {
41770 if(!isWasmInitialized) {
41771 throw new Error("initializeWasm() must be awaited first!");
41773 const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
41774 return nativeResponseValue;
41776 // struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
41778 export function Quantity_clone(orig: bigint): bigint {
41779 if(!isWasmInitialized) {
41780 throw new Error("initializeWasm() must be awaited first!");
41782 const nativeResponseValue = wasm.TS_Quantity_clone(orig);
41783 return nativeResponseValue;
41785 // struct LDKCResult_OfferBolt12ParseErrorZ Offer_from_str(struct LDKStr s);
41787 export function Offer_from_str(s: number): bigint {
41788 if(!isWasmInitialized) {
41789 throw new Error("initializeWasm() must be awaited first!");
41791 const nativeResponseValue = wasm.TS_Offer_from_str(s);
41792 return nativeResponseValue;
41794 // void UnsignedBolt12Invoice_free(struct LDKUnsignedBolt12Invoice this_obj);
41796 export function UnsignedBolt12Invoice_free(this_obj: bigint): void {
41797 if(!isWasmInitialized) {
41798 throw new Error("initializeWasm() must be awaited first!");
41800 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_free(this_obj);
41801 // debug statements here
41803 // MUST_USE_RES struct LDKTaggedHash UnsignedBolt12Invoice_tagged_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41805 export function UnsignedBolt12Invoice_tagged_hash(this_arg: bigint): bigint {
41806 if(!isWasmInitialized) {
41807 throw new Error("initializeWasm() must be awaited first!");
41809 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_tagged_hash(this_arg);
41810 return nativeResponseValue;
41812 // void Bolt12Invoice_free(struct LDKBolt12Invoice this_obj);
41814 export function Bolt12Invoice_free(this_obj: bigint): void {
41815 if(!isWasmInitialized) {
41816 throw new Error("initializeWasm() must be awaited first!");
41818 const nativeResponseValue = wasm.TS_Bolt12Invoice_free(this_obj);
41819 // debug statements here
41821 // uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg);
41823 export function Bolt12Invoice_clone_ptr(arg: bigint): bigint {
41824 if(!isWasmInitialized) {
41825 throw new Error("initializeWasm() must be awaited first!");
41827 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone_ptr(arg);
41828 return nativeResponseValue;
41830 // struct LDKBolt12Invoice Bolt12Invoice_clone(const struct LDKBolt12Invoice *NONNULL_PTR orig);
41832 export function Bolt12Invoice_clone(orig: bigint): bigint {
41833 if(!isWasmInitialized) {
41834 throw new Error("initializeWasm() must be awaited first!");
41836 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone(orig);
41837 return nativeResponseValue;
41839 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ UnsignedBolt12Invoice_offer_chains(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41841 export function UnsignedBolt12Invoice_offer_chains(this_arg: bigint): bigint {
41842 if(!isWasmInitialized) {
41843 throw new Error("initializeWasm() must be awaited first!");
41845 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_chains(this_arg);
41846 return nativeResponseValue;
41848 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_chain(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41850 export function UnsignedBolt12Invoice_chain(this_arg: bigint): number {
41851 if(!isWasmInitialized) {
41852 throw new Error("initializeWasm() must be awaited first!");
41854 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_chain(this_arg);
41855 return nativeResponseValue;
41857 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedBolt12Invoice_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41859 export function UnsignedBolt12Invoice_metadata(this_arg: bigint): bigint {
41860 if(!isWasmInitialized) {
41861 throw new Error("initializeWasm() must be awaited first!");
41863 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_metadata(this_arg);
41864 return nativeResponseValue;
41866 // MUST_USE_RES struct LDKAmount UnsignedBolt12Invoice_amount(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41868 export function UnsignedBolt12Invoice_amount(this_arg: bigint): bigint {
41869 if(!isWasmInitialized) {
41870 throw new Error("initializeWasm() must be awaited first!");
41872 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount(this_arg);
41873 return nativeResponseValue;
41875 // MUST_USE_RES struct LDKOfferFeatures UnsignedBolt12Invoice_offer_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41877 export function UnsignedBolt12Invoice_offer_features(this_arg: bigint): bigint {
41878 if(!isWasmInitialized) {
41879 throw new Error("initializeWasm() must be awaited first!");
41881 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_features(this_arg);
41882 return nativeResponseValue;
41884 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_description(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41886 export function UnsignedBolt12Invoice_description(this_arg: bigint): bigint {
41887 if(!isWasmInitialized) {
41888 throw new Error("initializeWasm() must be awaited first!");
41890 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_description(this_arg);
41891 return nativeResponseValue;
41893 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_absolute_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41895 export function UnsignedBolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
41896 if(!isWasmInitialized) {
41897 throw new Error("initializeWasm() must be awaited first!");
41899 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_absolute_expiry(this_arg);
41900 return nativeResponseValue;
41902 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_issuer(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41904 export function UnsignedBolt12Invoice_issuer(this_arg: bigint): bigint {
41905 if(!isWasmInitialized) {
41906 throw new Error("initializeWasm() must be awaited first!");
41908 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_issuer(this_arg);
41909 return nativeResponseValue;
41911 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedBolt12Invoice_message_paths(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41913 export function UnsignedBolt12Invoice_message_paths(this_arg: bigint): number {
41914 if(!isWasmInitialized) {
41915 throw new Error("initializeWasm() must be awaited first!");
41917 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_message_paths(this_arg);
41918 return nativeResponseValue;
41920 // MUST_USE_RES struct LDKQuantity UnsignedBolt12Invoice_supported_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41922 export function UnsignedBolt12Invoice_supported_quantity(this_arg: bigint): bigint {
41923 if(!isWasmInitialized) {
41924 throw new Error("initializeWasm() must be awaited first!");
41926 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_supported_quantity(this_arg);
41927 return nativeResponseValue;
41929 // MUST_USE_RES struct LDKu8slice UnsignedBolt12Invoice_payer_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41931 export function UnsignedBolt12Invoice_payer_metadata(this_arg: bigint): number {
41932 if(!isWasmInitialized) {
41933 throw new Error("initializeWasm() must be awaited first!");
41935 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_metadata(this_arg);
41936 return nativeResponseValue;
41938 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedBolt12Invoice_invoice_request_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41940 export function UnsignedBolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
41941 if(!isWasmInitialized) {
41942 throw new Error("initializeWasm() must be awaited first!");
41944 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_request_features(this_arg);
41945 return nativeResponseValue;
41947 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41949 export function UnsignedBolt12Invoice_quantity(this_arg: bigint): bigint {
41950 if(!isWasmInitialized) {
41951 throw new Error("initializeWasm() must be awaited first!");
41953 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_quantity(this_arg);
41954 return nativeResponseValue;
41956 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_payer_id(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41958 export function UnsignedBolt12Invoice_payer_id(this_arg: bigint): number {
41959 if(!isWasmInitialized) {
41960 throw new Error("initializeWasm() must be awaited first!");
41962 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_id(this_arg);
41963 return nativeResponseValue;
41965 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_payer_note(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41967 export function UnsignedBolt12Invoice_payer_note(this_arg: bigint): bigint {
41968 if(!isWasmInitialized) {
41969 throw new Error("initializeWasm() must be awaited first!");
41971 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_note(this_arg);
41972 return nativeResponseValue;
41974 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_created_at(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41976 export function UnsignedBolt12Invoice_created_at(this_arg: bigint): bigint {
41977 if(!isWasmInitialized) {
41978 throw new Error("initializeWasm() must be awaited first!");
41980 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_created_at(this_arg);
41981 return nativeResponseValue;
41983 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_relative_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41985 export function UnsignedBolt12Invoice_relative_expiry(this_arg: bigint): bigint {
41986 if(!isWasmInitialized) {
41987 throw new Error("initializeWasm() must be awaited first!");
41989 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_relative_expiry(this_arg);
41990 return nativeResponseValue;
41992 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_payment_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
41994 export function UnsignedBolt12Invoice_payment_hash(this_arg: bigint): number {
41995 if(!isWasmInitialized) {
41996 throw new Error("initializeWasm() must be awaited first!");
41998 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payment_hash(this_arg);
41999 return nativeResponseValue;
42001 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_amount_msats(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42003 export function UnsignedBolt12Invoice_amount_msats(this_arg: bigint): bigint {
42004 if(!isWasmInitialized) {
42005 throw new Error("initializeWasm() must be awaited first!");
42007 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount_msats(this_arg);
42008 return nativeResponseValue;
42010 // MUST_USE_RES struct LDKBolt12InvoiceFeatures UnsignedBolt12Invoice_invoice_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42012 export function UnsignedBolt12Invoice_invoice_features(this_arg: bigint): bigint {
42013 if(!isWasmInitialized) {
42014 throw new Error("initializeWasm() must be awaited first!");
42016 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_features(this_arg);
42017 return nativeResponseValue;
42019 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_signing_pubkey(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42021 export function UnsignedBolt12Invoice_signing_pubkey(this_arg: bigint): number {
42022 if(!isWasmInitialized) {
42023 throw new Error("initializeWasm() must be awaited first!");
42025 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_signing_pubkey(this_arg);
42026 return nativeResponseValue;
42028 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ Bolt12Invoice_offer_chains(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42030 export function Bolt12Invoice_offer_chains(this_arg: bigint): bigint {
42031 if(!isWasmInitialized) {
42032 throw new Error("initializeWasm() must be awaited first!");
42034 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_chains(this_arg);
42035 return nativeResponseValue;
42037 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_chain(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42039 export function Bolt12Invoice_chain(this_arg: bigint): number {
42040 if(!isWasmInitialized) {
42041 throw new Error("initializeWasm() must be awaited first!");
42043 const nativeResponseValue = wasm.TS_Bolt12Invoice_chain(this_arg);
42044 return nativeResponseValue;
42046 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt12Invoice_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42048 export function Bolt12Invoice_metadata(this_arg: bigint): bigint {
42049 if(!isWasmInitialized) {
42050 throw new Error("initializeWasm() must be awaited first!");
42052 const nativeResponseValue = wasm.TS_Bolt12Invoice_metadata(this_arg);
42053 return nativeResponseValue;
42055 // MUST_USE_RES struct LDKAmount Bolt12Invoice_amount(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42057 export function Bolt12Invoice_amount(this_arg: bigint): bigint {
42058 if(!isWasmInitialized) {
42059 throw new Error("initializeWasm() must be awaited first!");
42061 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount(this_arg);
42062 return nativeResponseValue;
42064 // MUST_USE_RES struct LDKOfferFeatures Bolt12Invoice_offer_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42066 export function Bolt12Invoice_offer_features(this_arg: bigint): bigint {
42067 if(!isWasmInitialized) {
42068 throw new Error("initializeWasm() must be awaited first!");
42070 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_features(this_arg);
42071 return nativeResponseValue;
42073 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_description(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42075 export function Bolt12Invoice_description(this_arg: bigint): bigint {
42076 if(!isWasmInitialized) {
42077 throw new Error("initializeWasm() must be awaited first!");
42079 const nativeResponseValue = wasm.TS_Bolt12Invoice_description(this_arg);
42080 return nativeResponseValue;
42082 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_absolute_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42084 export function Bolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
42085 if(!isWasmInitialized) {
42086 throw new Error("initializeWasm() must be awaited first!");
42088 const nativeResponseValue = wasm.TS_Bolt12Invoice_absolute_expiry(this_arg);
42089 return nativeResponseValue;
42091 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_issuer(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42093 export function Bolt12Invoice_issuer(this_arg: bigint): bigint {
42094 if(!isWasmInitialized) {
42095 throw new Error("initializeWasm() must be awaited first!");
42097 const nativeResponseValue = wasm.TS_Bolt12Invoice_issuer(this_arg);
42098 return nativeResponseValue;
42100 // MUST_USE_RES struct LDKCVec_BlindedPathZ Bolt12Invoice_message_paths(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42102 export function Bolt12Invoice_message_paths(this_arg: bigint): number {
42103 if(!isWasmInitialized) {
42104 throw new Error("initializeWasm() must be awaited first!");
42106 const nativeResponseValue = wasm.TS_Bolt12Invoice_message_paths(this_arg);
42107 return nativeResponseValue;
42109 // MUST_USE_RES struct LDKQuantity Bolt12Invoice_supported_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42111 export function Bolt12Invoice_supported_quantity(this_arg: bigint): bigint {
42112 if(!isWasmInitialized) {
42113 throw new Error("initializeWasm() must be awaited first!");
42115 const nativeResponseValue = wasm.TS_Bolt12Invoice_supported_quantity(this_arg);
42116 return nativeResponseValue;
42118 // MUST_USE_RES struct LDKu8slice Bolt12Invoice_payer_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42120 export function Bolt12Invoice_payer_metadata(this_arg: bigint): number {
42121 if(!isWasmInitialized) {
42122 throw new Error("initializeWasm() must be awaited first!");
42124 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_metadata(this_arg);
42125 return nativeResponseValue;
42127 // MUST_USE_RES struct LDKInvoiceRequestFeatures Bolt12Invoice_invoice_request_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42129 export function Bolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
42130 if(!isWasmInitialized) {
42131 throw new Error("initializeWasm() must be awaited first!");
42133 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_request_features(this_arg);
42134 return nativeResponseValue;
42136 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42138 export function Bolt12Invoice_quantity(this_arg: bigint): bigint {
42139 if(!isWasmInitialized) {
42140 throw new Error("initializeWasm() must be awaited first!");
42142 const nativeResponseValue = wasm.TS_Bolt12Invoice_quantity(this_arg);
42143 return nativeResponseValue;
42145 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_payer_id(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42147 export function Bolt12Invoice_payer_id(this_arg: bigint): number {
42148 if(!isWasmInitialized) {
42149 throw new Error("initializeWasm() must be awaited first!");
42151 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_id(this_arg);
42152 return nativeResponseValue;
42154 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_payer_note(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42156 export function Bolt12Invoice_payer_note(this_arg: bigint): bigint {
42157 if(!isWasmInitialized) {
42158 throw new Error("initializeWasm() must be awaited first!");
42160 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_note(this_arg);
42161 return nativeResponseValue;
42163 // MUST_USE_RES uint64_t Bolt12Invoice_created_at(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42165 export function Bolt12Invoice_created_at(this_arg: bigint): bigint {
42166 if(!isWasmInitialized) {
42167 throw new Error("initializeWasm() must be awaited first!");
42169 const nativeResponseValue = wasm.TS_Bolt12Invoice_created_at(this_arg);
42170 return nativeResponseValue;
42172 // MUST_USE_RES uint64_t Bolt12Invoice_relative_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42174 export function Bolt12Invoice_relative_expiry(this_arg: bigint): bigint {
42175 if(!isWasmInitialized) {
42176 throw new Error("initializeWasm() must be awaited first!");
42178 const nativeResponseValue = wasm.TS_Bolt12Invoice_relative_expiry(this_arg);
42179 return nativeResponseValue;
42181 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_payment_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42183 export function Bolt12Invoice_payment_hash(this_arg: bigint): number {
42184 if(!isWasmInitialized) {
42185 throw new Error("initializeWasm() must be awaited first!");
42187 const nativeResponseValue = wasm.TS_Bolt12Invoice_payment_hash(this_arg);
42188 return nativeResponseValue;
42190 // MUST_USE_RES uint64_t Bolt12Invoice_amount_msats(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42192 export function Bolt12Invoice_amount_msats(this_arg: bigint): bigint {
42193 if(!isWasmInitialized) {
42194 throw new Error("initializeWasm() must be awaited first!");
42196 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount_msats(this_arg);
42197 return nativeResponseValue;
42199 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12Invoice_invoice_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42201 export function Bolt12Invoice_invoice_features(this_arg: bigint): bigint {
42202 if(!isWasmInitialized) {
42203 throw new Error("initializeWasm() must be awaited first!");
42205 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_features(this_arg);
42206 return nativeResponseValue;
42208 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_signing_pubkey(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42210 export function Bolt12Invoice_signing_pubkey(this_arg: bigint): number {
42211 if(!isWasmInitialized) {
42212 throw new Error("initializeWasm() must be awaited first!");
42214 const nativeResponseValue = wasm.TS_Bolt12Invoice_signing_pubkey(this_arg);
42215 return nativeResponseValue;
42217 // MUST_USE_RES struct LDKSchnorrSignature Bolt12Invoice_signature(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42219 export function Bolt12Invoice_signature(this_arg: bigint): number {
42220 if(!isWasmInitialized) {
42221 throw new Error("initializeWasm() must be awaited first!");
42223 const nativeResponseValue = wasm.TS_Bolt12Invoice_signature(this_arg);
42224 return nativeResponseValue;
42226 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_signable_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42228 export function Bolt12Invoice_signable_hash(this_arg: bigint): number {
42229 if(!isWasmInitialized) {
42230 throw new Error("initializeWasm() must be awaited first!");
42232 const nativeResponseValue = wasm.TS_Bolt12Invoice_signable_hash(this_arg);
42233 return nativeResponseValue;
42235 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ Bolt12Invoice_verify(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
42237 export function Bolt12Invoice_verify(this_arg: bigint, key: bigint): bigint {
42238 if(!isWasmInitialized) {
42239 throw new Error("initializeWasm() must be awaited first!");
42241 const nativeResponseValue = wasm.TS_Bolt12Invoice_verify(this_arg, key);
42242 return nativeResponseValue;
42244 // struct LDKCVec_u8Z UnsignedBolt12Invoice_write(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR obj);
42246 export function UnsignedBolt12Invoice_write(obj: bigint): number {
42247 if(!isWasmInitialized) {
42248 throw new Error("initializeWasm() must be awaited first!");
42250 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_write(obj);
42251 return nativeResponseValue;
42253 // struct LDKCVec_u8Z Bolt12Invoice_write(const struct LDKBolt12Invoice *NONNULL_PTR obj);
42255 export function Bolt12Invoice_write(obj: bigint): number {
42256 if(!isWasmInitialized) {
42257 throw new Error("initializeWasm() must be awaited first!");
42259 const nativeResponseValue = wasm.TS_Bolt12Invoice_write(obj);
42260 return nativeResponseValue;
42262 // void BlindedPayInfo_free(struct LDKBlindedPayInfo this_obj);
42264 export function BlindedPayInfo_free(this_obj: bigint): void {
42265 if(!isWasmInitialized) {
42266 throw new Error("initializeWasm() must be awaited first!");
42268 const nativeResponseValue = wasm.TS_BlindedPayInfo_free(this_obj);
42269 // debug statements here
42271 // uint32_t BlindedPayInfo_get_fee_base_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42273 export function BlindedPayInfo_get_fee_base_msat(this_ptr: bigint): number {
42274 if(!isWasmInitialized) {
42275 throw new Error("initializeWasm() must be awaited first!");
42277 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_base_msat(this_ptr);
42278 return nativeResponseValue;
42280 // void BlindedPayInfo_set_fee_base_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
42282 export function BlindedPayInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
42283 if(!isWasmInitialized) {
42284 throw new Error("initializeWasm() must be awaited first!");
42286 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_base_msat(this_ptr, val);
42287 // debug statements here
42289 // uint32_t BlindedPayInfo_get_fee_proportional_millionths(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42291 export function BlindedPayInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
42292 if(!isWasmInitialized) {
42293 throw new Error("initializeWasm() must be awaited first!");
42295 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_proportional_millionths(this_ptr);
42296 return nativeResponseValue;
42298 // void BlindedPayInfo_set_fee_proportional_millionths(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
42300 export function BlindedPayInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
42301 if(!isWasmInitialized) {
42302 throw new Error("initializeWasm() must be awaited first!");
42304 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_proportional_millionths(this_ptr, val);
42305 // debug statements here
42307 // uint16_t BlindedPayInfo_get_cltv_expiry_delta(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42309 export function BlindedPayInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
42310 if(!isWasmInitialized) {
42311 throw new Error("initializeWasm() must be awaited first!");
42313 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_cltv_expiry_delta(this_ptr);
42314 return nativeResponseValue;
42316 // void BlindedPayInfo_set_cltv_expiry_delta(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint16_t val);
42318 export function BlindedPayInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
42319 if(!isWasmInitialized) {
42320 throw new Error("initializeWasm() must be awaited first!");
42322 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_cltv_expiry_delta(this_ptr, val);
42323 // debug statements here
42325 // uint64_t BlindedPayInfo_get_htlc_minimum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42327 export function BlindedPayInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
42328 if(!isWasmInitialized) {
42329 throw new Error("initializeWasm() must be awaited first!");
42331 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_minimum_msat(this_ptr);
42332 return nativeResponseValue;
42334 // void BlindedPayInfo_set_htlc_minimum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
42336 export function BlindedPayInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
42337 if(!isWasmInitialized) {
42338 throw new Error("initializeWasm() must be awaited first!");
42340 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_minimum_msat(this_ptr, val);
42341 // debug statements here
42343 // uint64_t BlindedPayInfo_get_htlc_maximum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42345 export function BlindedPayInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
42346 if(!isWasmInitialized) {
42347 throw new Error("initializeWasm() must be awaited first!");
42349 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_maximum_msat(this_ptr);
42350 return nativeResponseValue;
42352 // void BlindedPayInfo_set_htlc_maximum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
42354 export function BlindedPayInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
42355 if(!isWasmInitialized) {
42356 throw new Error("initializeWasm() must be awaited first!");
42358 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_maximum_msat(this_ptr, val);
42359 // debug statements here
42361 // struct LDKBlindedHopFeatures BlindedPayInfo_get_features(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42363 export function BlindedPayInfo_get_features(this_ptr: bigint): bigint {
42364 if(!isWasmInitialized) {
42365 throw new Error("initializeWasm() must be awaited first!");
42367 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_features(this_ptr);
42368 return nativeResponseValue;
42370 // void BlindedPayInfo_set_features(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
42372 export function BlindedPayInfo_set_features(this_ptr: bigint, val: bigint): void {
42373 if(!isWasmInitialized) {
42374 throw new Error("initializeWasm() must be awaited first!");
42376 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_features(this_ptr, val);
42377 // debug statements here
42379 // 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);
42381 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 {
42382 if(!isWasmInitialized) {
42383 throw new Error("initializeWasm() must be awaited first!");
42385 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);
42386 return nativeResponseValue;
42388 // uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg);
42390 export function BlindedPayInfo_clone_ptr(arg: bigint): bigint {
42391 if(!isWasmInitialized) {
42392 throw new Error("initializeWasm() must be awaited first!");
42394 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone_ptr(arg);
42395 return nativeResponseValue;
42397 // struct LDKBlindedPayInfo BlindedPayInfo_clone(const struct LDKBlindedPayInfo *NONNULL_PTR orig);
42399 export function BlindedPayInfo_clone(orig: bigint): bigint {
42400 if(!isWasmInitialized) {
42401 throw new Error("initializeWasm() must be awaited first!");
42403 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone(orig);
42404 return nativeResponseValue;
42406 // uint64_t BlindedPayInfo_hash(const struct LDKBlindedPayInfo *NONNULL_PTR o);
42408 export function BlindedPayInfo_hash(o: bigint): bigint {
42409 if(!isWasmInitialized) {
42410 throw new Error("initializeWasm() must be awaited first!");
42412 const nativeResponseValue = wasm.TS_BlindedPayInfo_hash(o);
42413 return nativeResponseValue;
42415 // bool BlindedPayInfo_eq(const struct LDKBlindedPayInfo *NONNULL_PTR a, const struct LDKBlindedPayInfo *NONNULL_PTR b);
42417 export function BlindedPayInfo_eq(a: bigint, b: bigint): boolean {
42418 if(!isWasmInitialized) {
42419 throw new Error("initializeWasm() must be awaited first!");
42421 const nativeResponseValue = wasm.TS_BlindedPayInfo_eq(a, b);
42422 return nativeResponseValue;
42424 // struct LDKCVec_u8Z BlindedPayInfo_write(const struct LDKBlindedPayInfo *NONNULL_PTR obj);
42426 export function BlindedPayInfo_write(obj: bigint): number {
42427 if(!isWasmInitialized) {
42428 throw new Error("initializeWasm() must be awaited first!");
42430 const nativeResponseValue = wasm.TS_BlindedPayInfo_write(obj);
42431 return nativeResponseValue;
42433 // struct LDKCResult_BlindedPayInfoDecodeErrorZ BlindedPayInfo_read(struct LDKu8slice ser);
42435 export function BlindedPayInfo_read(ser: number): bigint {
42436 if(!isWasmInitialized) {
42437 throw new Error("initializeWasm() must be awaited first!");
42439 const nativeResponseValue = wasm.TS_BlindedPayInfo_read(ser);
42440 return nativeResponseValue;
42442 // void InvoiceError_free(struct LDKInvoiceError this_obj);
42444 export function InvoiceError_free(this_obj: bigint): void {
42445 if(!isWasmInitialized) {
42446 throw new Error("initializeWasm() must be awaited first!");
42448 const nativeResponseValue = wasm.TS_InvoiceError_free(this_obj);
42449 // debug statements here
42451 // struct LDKErroneousField InvoiceError_get_erroneous_field(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
42453 export function InvoiceError_get_erroneous_field(this_ptr: bigint): bigint {
42454 if(!isWasmInitialized) {
42455 throw new Error("initializeWasm() must be awaited first!");
42457 const nativeResponseValue = wasm.TS_InvoiceError_get_erroneous_field(this_ptr);
42458 return nativeResponseValue;
42460 // void InvoiceError_set_erroneous_field(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKErroneousField val);
42462 export function InvoiceError_set_erroneous_field(this_ptr: bigint, val: bigint): void {
42463 if(!isWasmInitialized) {
42464 throw new Error("initializeWasm() must be awaited first!");
42466 const nativeResponseValue = wasm.TS_InvoiceError_set_erroneous_field(this_ptr, val);
42467 // debug statements here
42469 // struct LDKUntrustedString InvoiceError_get_message(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
42471 export function InvoiceError_get_message(this_ptr: bigint): bigint {
42472 if(!isWasmInitialized) {
42473 throw new Error("initializeWasm() must be awaited first!");
42475 const nativeResponseValue = wasm.TS_InvoiceError_get_message(this_ptr);
42476 return nativeResponseValue;
42478 // void InvoiceError_set_message(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
42480 export function InvoiceError_set_message(this_ptr: bigint, val: bigint): void {
42481 if(!isWasmInitialized) {
42482 throw new Error("initializeWasm() must be awaited first!");
42484 const nativeResponseValue = wasm.TS_InvoiceError_set_message(this_ptr, val);
42485 // debug statements here
42487 // MUST_USE_RES struct LDKInvoiceError InvoiceError_new(struct LDKErroneousField erroneous_field_arg, struct LDKUntrustedString message_arg);
42489 export function InvoiceError_new(erroneous_field_arg: bigint, message_arg: bigint): bigint {
42490 if(!isWasmInitialized) {
42491 throw new Error("initializeWasm() must be awaited first!");
42493 const nativeResponseValue = wasm.TS_InvoiceError_new(erroneous_field_arg, message_arg);
42494 return nativeResponseValue;
42496 // uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg);
42498 export function InvoiceError_clone_ptr(arg: bigint): bigint {
42499 if(!isWasmInitialized) {
42500 throw new Error("initializeWasm() must be awaited first!");
42502 const nativeResponseValue = wasm.TS_InvoiceError_clone_ptr(arg);
42503 return nativeResponseValue;
42505 // struct LDKInvoiceError InvoiceError_clone(const struct LDKInvoiceError *NONNULL_PTR orig);
42507 export function InvoiceError_clone(orig: bigint): bigint {
42508 if(!isWasmInitialized) {
42509 throw new Error("initializeWasm() must be awaited first!");
42511 const nativeResponseValue = wasm.TS_InvoiceError_clone(orig);
42512 return nativeResponseValue;
42514 // void ErroneousField_free(struct LDKErroneousField this_obj);
42516 export function ErroneousField_free(this_obj: bigint): void {
42517 if(!isWasmInitialized) {
42518 throw new Error("initializeWasm() must be awaited first!");
42520 const nativeResponseValue = wasm.TS_ErroneousField_free(this_obj);
42521 // debug statements here
42523 // uint64_t ErroneousField_get_tlv_fieldnum(const struct LDKErroneousField *NONNULL_PTR this_ptr);
42525 export function ErroneousField_get_tlv_fieldnum(this_ptr: bigint): bigint {
42526 if(!isWasmInitialized) {
42527 throw new Error("initializeWasm() must be awaited first!");
42529 const nativeResponseValue = wasm.TS_ErroneousField_get_tlv_fieldnum(this_ptr);
42530 return nativeResponseValue;
42532 // void ErroneousField_set_tlv_fieldnum(struct LDKErroneousField *NONNULL_PTR this_ptr, uint64_t val);
42534 export function ErroneousField_set_tlv_fieldnum(this_ptr: bigint, val: bigint): void {
42535 if(!isWasmInitialized) {
42536 throw new Error("initializeWasm() must be awaited first!");
42538 const nativeResponseValue = wasm.TS_ErroneousField_set_tlv_fieldnum(this_ptr, val);
42539 // debug statements here
42541 // struct LDKCOption_CVec_u8ZZ ErroneousField_get_suggested_value(const struct LDKErroneousField *NONNULL_PTR this_ptr);
42543 export function ErroneousField_get_suggested_value(this_ptr: bigint): bigint {
42544 if(!isWasmInitialized) {
42545 throw new Error("initializeWasm() must be awaited first!");
42547 const nativeResponseValue = wasm.TS_ErroneousField_get_suggested_value(this_ptr);
42548 return nativeResponseValue;
42550 // void ErroneousField_set_suggested_value(struct LDKErroneousField *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
42552 export function ErroneousField_set_suggested_value(this_ptr: bigint, val: bigint): void {
42553 if(!isWasmInitialized) {
42554 throw new Error("initializeWasm() must be awaited first!");
42556 const nativeResponseValue = wasm.TS_ErroneousField_set_suggested_value(this_ptr, val);
42557 // debug statements here
42559 // MUST_USE_RES struct LDKErroneousField ErroneousField_new(uint64_t tlv_fieldnum_arg, struct LDKCOption_CVec_u8ZZ suggested_value_arg);
42561 export function ErroneousField_new(tlv_fieldnum_arg: bigint, suggested_value_arg: bigint): bigint {
42562 if(!isWasmInitialized) {
42563 throw new Error("initializeWasm() must be awaited first!");
42565 const nativeResponseValue = wasm.TS_ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg);
42566 return nativeResponseValue;
42568 // uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg);
42570 export function ErroneousField_clone_ptr(arg: bigint): bigint {
42571 if(!isWasmInitialized) {
42572 throw new Error("initializeWasm() must be awaited first!");
42574 const nativeResponseValue = wasm.TS_ErroneousField_clone_ptr(arg);
42575 return nativeResponseValue;
42577 // struct LDKErroneousField ErroneousField_clone(const struct LDKErroneousField *NONNULL_PTR orig);
42579 export function ErroneousField_clone(orig: bigint): bigint {
42580 if(!isWasmInitialized) {
42581 throw new Error("initializeWasm() must be awaited first!");
42583 const nativeResponseValue = wasm.TS_ErroneousField_clone(orig);
42584 return nativeResponseValue;
42586 // struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
42588 export function InvoiceError_write(obj: bigint): number {
42589 if(!isWasmInitialized) {
42590 throw new Error("initializeWasm() must be awaited first!");
42592 const nativeResponseValue = wasm.TS_InvoiceError_write(obj);
42593 return nativeResponseValue;
42595 // struct LDKCResult_InvoiceErrorDecodeErrorZ InvoiceError_read(struct LDKu8slice ser);
42597 export function InvoiceError_read(ser: number): bigint {
42598 if(!isWasmInitialized) {
42599 throw new Error("initializeWasm() must be awaited first!");
42601 const nativeResponseValue = wasm.TS_InvoiceError_read(ser);
42602 return nativeResponseValue;
42604 // void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
42606 export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
42607 if(!isWasmInitialized) {
42608 throw new Error("initializeWasm() must be awaited first!");
42610 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
42611 // debug statements here
42613 // MUST_USE_RES struct LDKTaggedHash UnsignedInvoiceRequest_tagged_hash(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42615 export function UnsignedInvoiceRequest_tagged_hash(this_arg: bigint): bigint {
42616 if(!isWasmInitialized) {
42617 throw new Error("initializeWasm() must be awaited first!");
42619 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_tagged_hash(this_arg);
42620 return nativeResponseValue;
42622 // void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
42624 export function InvoiceRequest_free(this_obj: bigint): void {
42625 if(!isWasmInitialized) {
42626 throw new Error("initializeWasm() must be awaited first!");
42628 const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
42629 // debug statements here
42631 // uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
42633 export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
42634 if(!isWasmInitialized) {
42635 throw new Error("initializeWasm() must be awaited first!");
42637 const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
42638 return nativeResponseValue;
42640 // struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
42642 export function InvoiceRequest_clone(orig: bigint): bigint {
42643 if(!isWasmInitialized) {
42644 throw new Error("initializeWasm() must be awaited first!");
42646 const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
42647 return nativeResponseValue;
42649 // void VerifiedInvoiceRequest_free(struct LDKVerifiedInvoiceRequest this_obj);
42651 export function VerifiedInvoiceRequest_free(this_obj: bigint): void {
42652 if(!isWasmInitialized) {
42653 throw new Error("initializeWasm() must be awaited first!");
42655 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_free(this_obj);
42656 // debug statements here
42658 // struct LDKCOption_SecretKeyZ VerifiedInvoiceRequest_get_keys(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr);
42660 export function VerifiedInvoiceRequest_get_keys(this_ptr: bigint): bigint {
42661 if(!isWasmInitialized) {
42662 throw new Error("initializeWasm() must be awaited first!");
42664 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_get_keys(this_ptr);
42665 return nativeResponseValue;
42667 // void VerifiedInvoiceRequest_set_keys(struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr, struct LDKCOption_SecretKeyZ val);
42669 export function VerifiedInvoiceRequest_set_keys(this_ptr: bigint, val: bigint): void {
42670 if(!isWasmInitialized) {
42671 throw new Error("initializeWasm() must be awaited first!");
42673 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_set_keys(this_ptr, val);
42674 // debug statements here
42676 // uint64_t VerifiedInvoiceRequest_clone_ptr(LDKVerifiedInvoiceRequest *NONNULL_PTR arg);
42678 export function VerifiedInvoiceRequest_clone_ptr(arg: bigint): bigint {
42679 if(!isWasmInitialized) {
42680 throw new Error("initializeWasm() must be awaited first!");
42682 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone_ptr(arg);
42683 return nativeResponseValue;
42685 // struct LDKVerifiedInvoiceRequest VerifiedInvoiceRequest_clone(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR orig);
42687 export function VerifiedInvoiceRequest_clone(orig: bigint): bigint {
42688 if(!isWasmInitialized) {
42689 throw new Error("initializeWasm() must be awaited first!");
42691 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone(orig);
42692 return nativeResponseValue;
42694 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ UnsignedInvoiceRequest_chains(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42696 export function UnsignedInvoiceRequest_chains(this_arg: bigint): number {
42697 if(!isWasmInitialized) {
42698 throw new Error("initializeWasm() must be awaited first!");
42700 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chains(this_arg);
42701 return nativeResponseValue;
42703 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedInvoiceRequest_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42705 export function UnsignedInvoiceRequest_metadata(this_arg: bigint): bigint {
42706 if(!isWasmInitialized) {
42707 throw new Error("initializeWasm() must be awaited first!");
42709 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_metadata(this_arg);
42710 return nativeResponseValue;
42712 // MUST_USE_RES struct LDKAmount UnsignedInvoiceRequest_amount(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42714 export function UnsignedInvoiceRequest_amount(this_arg: bigint): bigint {
42715 if(!isWasmInitialized) {
42716 throw new Error("initializeWasm() must be awaited first!");
42718 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount(this_arg);
42719 return nativeResponseValue;
42721 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_description(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42723 export function UnsignedInvoiceRequest_description(this_arg: bigint): bigint {
42724 if(!isWasmInitialized) {
42725 throw new Error("initializeWasm() must be awaited first!");
42727 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_description(this_arg);
42728 return nativeResponseValue;
42730 // MUST_USE_RES struct LDKOfferFeatures UnsignedInvoiceRequest_offer_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42732 export function UnsignedInvoiceRequest_offer_features(this_arg: bigint): bigint {
42733 if(!isWasmInitialized) {
42734 throw new Error("initializeWasm() must be awaited first!");
42736 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_offer_features(this_arg);
42737 return nativeResponseValue;
42739 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_absolute_expiry(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42741 export function UnsignedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
42742 if(!isWasmInitialized) {
42743 throw new Error("initializeWasm() must be awaited first!");
42745 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_absolute_expiry(this_arg);
42746 return nativeResponseValue;
42748 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_issuer(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42750 export function UnsignedInvoiceRequest_issuer(this_arg: bigint): bigint {
42751 if(!isWasmInitialized) {
42752 throw new Error("initializeWasm() must be awaited first!");
42754 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_issuer(this_arg);
42755 return nativeResponseValue;
42757 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedInvoiceRequest_paths(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42759 export function UnsignedInvoiceRequest_paths(this_arg: bigint): number {
42760 if(!isWasmInitialized) {
42761 throw new Error("initializeWasm() must be awaited first!");
42763 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_paths(this_arg);
42764 return nativeResponseValue;
42766 // MUST_USE_RES struct LDKQuantity UnsignedInvoiceRequest_supported_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42768 export function UnsignedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
42769 if(!isWasmInitialized) {
42770 throw new Error("initializeWasm() must be awaited first!");
42772 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_supported_quantity(this_arg);
42773 return nativeResponseValue;
42775 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_signing_pubkey(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42777 export function UnsignedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
42778 if(!isWasmInitialized) {
42779 throw new Error("initializeWasm() must be awaited first!");
42781 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_signing_pubkey(this_arg);
42782 return nativeResponseValue;
42784 // MUST_USE_RES struct LDKu8slice UnsignedInvoiceRequest_payer_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42786 export function UnsignedInvoiceRequest_payer_metadata(this_arg: bigint): number {
42787 if(!isWasmInitialized) {
42788 throw new Error("initializeWasm() must be awaited first!");
42790 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_metadata(this_arg);
42791 return nativeResponseValue;
42793 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedInvoiceRequest_chain(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42795 export function UnsignedInvoiceRequest_chain(this_arg: bigint): number {
42796 if(!isWasmInitialized) {
42797 throw new Error("initializeWasm() must be awaited first!");
42799 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chain(this_arg);
42800 return nativeResponseValue;
42802 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_amount_msats(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42804 export function UnsignedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
42805 if(!isWasmInitialized) {
42806 throw new Error("initializeWasm() must be awaited first!");
42808 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount_msats(this_arg);
42809 return nativeResponseValue;
42811 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedInvoiceRequest_invoice_request_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42813 export function UnsignedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
42814 if(!isWasmInitialized) {
42815 throw new Error("initializeWasm() must be awaited first!");
42817 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_invoice_request_features(this_arg);
42818 return nativeResponseValue;
42820 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42822 export function UnsignedInvoiceRequest_quantity(this_arg: bigint): bigint {
42823 if(!isWasmInitialized) {
42824 throw new Error("initializeWasm() must be awaited first!");
42826 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_quantity(this_arg);
42827 return nativeResponseValue;
42829 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_payer_id(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42831 export function UnsignedInvoiceRequest_payer_id(this_arg: bigint): number {
42832 if(!isWasmInitialized) {
42833 throw new Error("initializeWasm() must be awaited first!");
42835 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_id(this_arg);
42836 return nativeResponseValue;
42838 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_payer_note(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
42840 export function UnsignedInvoiceRequest_payer_note(this_arg: bigint): bigint {
42841 if(!isWasmInitialized) {
42842 throw new Error("initializeWasm() must be awaited first!");
42844 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_note(this_arg);
42845 return nativeResponseValue;
42847 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ InvoiceRequest_chains(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42849 export function InvoiceRequest_chains(this_arg: bigint): number {
42850 if(!isWasmInitialized) {
42851 throw new Error("initializeWasm() must be awaited first!");
42853 const nativeResponseValue = wasm.TS_InvoiceRequest_chains(this_arg);
42854 return nativeResponseValue;
42856 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42858 export function InvoiceRequest_metadata(this_arg: bigint): bigint {
42859 if(!isWasmInitialized) {
42860 throw new Error("initializeWasm() must be awaited first!");
42862 const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
42863 return nativeResponseValue;
42865 // MUST_USE_RES struct LDKAmount InvoiceRequest_amount(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42867 export function InvoiceRequest_amount(this_arg: bigint): bigint {
42868 if(!isWasmInitialized) {
42869 throw new Error("initializeWasm() must be awaited first!");
42871 const nativeResponseValue = wasm.TS_InvoiceRequest_amount(this_arg);
42872 return nativeResponseValue;
42874 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_description(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42876 export function InvoiceRequest_description(this_arg: bigint): bigint {
42877 if(!isWasmInitialized) {
42878 throw new Error("initializeWasm() must be awaited first!");
42880 const nativeResponseValue = wasm.TS_InvoiceRequest_description(this_arg);
42881 return nativeResponseValue;
42883 // MUST_USE_RES struct LDKOfferFeatures InvoiceRequest_offer_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42885 export function InvoiceRequest_offer_features(this_arg: bigint): bigint {
42886 if(!isWasmInitialized) {
42887 throw new Error("initializeWasm() must be awaited first!");
42889 const nativeResponseValue = wasm.TS_InvoiceRequest_offer_features(this_arg);
42890 return nativeResponseValue;
42892 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_absolute_expiry(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42894 export function InvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
42895 if(!isWasmInitialized) {
42896 throw new Error("initializeWasm() must be awaited first!");
42898 const nativeResponseValue = wasm.TS_InvoiceRequest_absolute_expiry(this_arg);
42899 return nativeResponseValue;
42901 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_issuer(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42903 export function InvoiceRequest_issuer(this_arg: bigint): bigint {
42904 if(!isWasmInitialized) {
42905 throw new Error("initializeWasm() must be awaited first!");
42907 const nativeResponseValue = wasm.TS_InvoiceRequest_issuer(this_arg);
42908 return nativeResponseValue;
42910 // MUST_USE_RES struct LDKCVec_BlindedPathZ InvoiceRequest_paths(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42912 export function InvoiceRequest_paths(this_arg: bigint): number {
42913 if(!isWasmInitialized) {
42914 throw new Error("initializeWasm() must be awaited first!");
42916 const nativeResponseValue = wasm.TS_InvoiceRequest_paths(this_arg);
42917 return nativeResponseValue;
42919 // MUST_USE_RES struct LDKQuantity InvoiceRequest_supported_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42921 export function InvoiceRequest_supported_quantity(this_arg: bigint): bigint {
42922 if(!isWasmInitialized) {
42923 throw new Error("initializeWasm() must be awaited first!");
42925 const nativeResponseValue = wasm.TS_InvoiceRequest_supported_quantity(this_arg);
42926 return nativeResponseValue;
42928 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_signing_pubkey(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42930 export function InvoiceRequest_signing_pubkey(this_arg: bigint): number {
42931 if(!isWasmInitialized) {
42932 throw new Error("initializeWasm() must be awaited first!");
42934 const nativeResponseValue = wasm.TS_InvoiceRequest_signing_pubkey(this_arg);
42935 return nativeResponseValue;
42937 // MUST_USE_RES struct LDKu8slice InvoiceRequest_payer_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42939 export function InvoiceRequest_payer_metadata(this_arg: bigint): number {
42940 if(!isWasmInitialized) {
42941 throw new Error("initializeWasm() must be awaited first!");
42943 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_metadata(this_arg);
42944 return nativeResponseValue;
42946 // MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42948 export function InvoiceRequest_chain(this_arg: bigint): number {
42949 if(!isWasmInitialized) {
42950 throw new Error("initializeWasm() must be awaited first!");
42952 const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
42953 return nativeResponseValue;
42955 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42957 export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
42958 if(!isWasmInitialized) {
42959 throw new Error("initializeWasm() must be awaited first!");
42961 const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
42962 return nativeResponseValue;
42964 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_invoice_request_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42966 export function InvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
42967 if(!isWasmInitialized) {
42968 throw new Error("initializeWasm() must be awaited first!");
42970 const nativeResponseValue = wasm.TS_InvoiceRequest_invoice_request_features(this_arg);
42971 return nativeResponseValue;
42973 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42975 export function InvoiceRequest_quantity(this_arg: bigint): bigint {
42976 if(!isWasmInitialized) {
42977 throw new Error("initializeWasm() must be awaited first!");
42979 const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
42980 return nativeResponseValue;
42982 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42984 export function InvoiceRequest_payer_id(this_arg: bigint): number {
42985 if(!isWasmInitialized) {
42986 throw new Error("initializeWasm() must be awaited first!");
42988 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
42989 return nativeResponseValue;
42991 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
42993 export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
42994 if(!isWasmInitialized) {
42995 throw new Error("initializeWasm() must be awaited first!");
42997 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
42998 return nativeResponseValue;
43000 // MUST_USE_RES struct LDKSchnorrSignature InvoiceRequest_signature(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43002 export function InvoiceRequest_signature(this_arg: bigint): number {
43003 if(!isWasmInitialized) {
43004 throw new Error("initializeWasm() must be awaited first!");
43006 const nativeResponseValue = wasm.TS_InvoiceRequest_signature(this_arg);
43007 return nativeResponseValue;
43009 // MUST_USE_RES struct LDKCResult_VerifiedInvoiceRequestNoneZ InvoiceRequest_verify(struct LDKInvoiceRequest this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
43011 export function InvoiceRequest_verify(this_arg: bigint, key: bigint): bigint {
43012 if(!isWasmInitialized) {
43013 throw new Error("initializeWasm() must be awaited first!");
43015 const nativeResponseValue = wasm.TS_InvoiceRequest_verify(this_arg, key);
43016 return nativeResponseValue;
43018 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ VerifiedInvoiceRequest_chains(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43020 export function VerifiedInvoiceRequest_chains(this_arg: bigint): number {
43021 if(!isWasmInitialized) {
43022 throw new Error("initializeWasm() must be awaited first!");
43024 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chains(this_arg);
43025 return nativeResponseValue;
43027 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ VerifiedInvoiceRequest_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43029 export function VerifiedInvoiceRequest_metadata(this_arg: bigint): bigint {
43030 if(!isWasmInitialized) {
43031 throw new Error("initializeWasm() must be awaited first!");
43033 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_metadata(this_arg);
43034 return nativeResponseValue;
43036 // MUST_USE_RES struct LDKAmount VerifiedInvoiceRequest_amount(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43038 export function VerifiedInvoiceRequest_amount(this_arg: bigint): bigint {
43039 if(!isWasmInitialized) {
43040 throw new Error("initializeWasm() must be awaited first!");
43042 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount(this_arg);
43043 return nativeResponseValue;
43045 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_description(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43047 export function VerifiedInvoiceRequest_description(this_arg: bigint): bigint {
43048 if(!isWasmInitialized) {
43049 throw new Error("initializeWasm() must be awaited first!");
43051 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_description(this_arg);
43052 return nativeResponseValue;
43054 // MUST_USE_RES struct LDKOfferFeatures VerifiedInvoiceRequest_offer_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43056 export function VerifiedInvoiceRequest_offer_features(this_arg: bigint): bigint {
43057 if(!isWasmInitialized) {
43058 throw new Error("initializeWasm() must be awaited first!");
43060 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_offer_features(this_arg);
43061 return nativeResponseValue;
43063 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_absolute_expiry(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43065 export function VerifiedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
43066 if(!isWasmInitialized) {
43067 throw new Error("initializeWasm() must be awaited first!");
43069 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_absolute_expiry(this_arg);
43070 return nativeResponseValue;
43072 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_issuer(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43074 export function VerifiedInvoiceRequest_issuer(this_arg: bigint): bigint {
43075 if(!isWasmInitialized) {
43076 throw new Error("initializeWasm() must be awaited first!");
43078 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_issuer(this_arg);
43079 return nativeResponseValue;
43081 // MUST_USE_RES struct LDKCVec_BlindedPathZ VerifiedInvoiceRequest_paths(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43083 export function VerifiedInvoiceRequest_paths(this_arg: bigint): number {
43084 if(!isWasmInitialized) {
43085 throw new Error("initializeWasm() must be awaited first!");
43087 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_paths(this_arg);
43088 return nativeResponseValue;
43090 // MUST_USE_RES struct LDKQuantity VerifiedInvoiceRequest_supported_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43092 export function VerifiedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
43093 if(!isWasmInitialized) {
43094 throw new Error("initializeWasm() must be awaited first!");
43096 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_supported_quantity(this_arg);
43097 return nativeResponseValue;
43099 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_signing_pubkey(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43101 export function VerifiedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
43102 if(!isWasmInitialized) {
43103 throw new Error("initializeWasm() must be awaited first!");
43105 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_signing_pubkey(this_arg);
43106 return nativeResponseValue;
43108 // MUST_USE_RES struct LDKu8slice VerifiedInvoiceRequest_payer_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43110 export function VerifiedInvoiceRequest_payer_metadata(this_arg: bigint): number {
43111 if(!isWasmInitialized) {
43112 throw new Error("initializeWasm() must be awaited first!");
43114 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_metadata(this_arg);
43115 return nativeResponseValue;
43117 // MUST_USE_RES struct LDKThirtyTwoBytes VerifiedInvoiceRequest_chain(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43119 export function VerifiedInvoiceRequest_chain(this_arg: bigint): number {
43120 if(!isWasmInitialized) {
43121 throw new Error("initializeWasm() must be awaited first!");
43123 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chain(this_arg);
43124 return nativeResponseValue;
43126 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_amount_msats(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43128 export function VerifiedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
43129 if(!isWasmInitialized) {
43130 throw new Error("initializeWasm() must be awaited first!");
43132 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount_msats(this_arg);
43133 return nativeResponseValue;
43135 // MUST_USE_RES struct LDKInvoiceRequestFeatures VerifiedInvoiceRequest_invoice_request_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43137 export function VerifiedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
43138 if(!isWasmInitialized) {
43139 throw new Error("initializeWasm() must be awaited first!");
43141 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_invoice_request_features(this_arg);
43142 return nativeResponseValue;
43144 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43146 export function VerifiedInvoiceRequest_quantity(this_arg: bigint): bigint {
43147 if(!isWasmInitialized) {
43148 throw new Error("initializeWasm() must be awaited first!");
43150 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_quantity(this_arg);
43151 return nativeResponseValue;
43153 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_payer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43155 export function VerifiedInvoiceRequest_payer_id(this_arg: bigint): number {
43156 if(!isWasmInitialized) {
43157 throw new Error("initializeWasm() must be awaited first!");
43159 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_id(this_arg);
43160 return nativeResponseValue;
43162 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_payer_note(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43164 export function VerifiedInvoiceRequest_payer_note(this_arg: bigint): bigint {
43165 if(!isWasmInitialized) {
43166 throw new Error("initializeWasm() must be awaited first!");
43168 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_note(this_arg);
43169 return nativeResponseValue;
43171 // struct LDKCVec_u8Z UnsignedInvoiceRequest_write(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR obj);
43173 export function UnsignedInvoiceRequest_write(obj: bigint): number {
43174 if(!isWasmInitialized) {
43175 throw new Error("initializeWasm() must be awaited first!");
43177 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_write(obj);
43178 return nativeResponseValue;
43180 // struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
43182 export function InvoiceRequest_write(obj: bigint): number {
43183 if(!isWasmInitialized) {
43184 throw new Error("initializeWasm() must be awaited first!");
43186 const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
43187 return nativeResponseValue;
43189 // void TaggedHash_free(struct LDKTaggedHash this_obj);
43191 export function TaggedHash_free(this_obj: bigint): void {
43192 if(!isWasmInitialized) {
43193 throw new Error("initializeWasm() must be awaited first!");
43195 const nativeResponseValue = wasm.TS_TaggedHash_free(this_obj);
43196 // debug statements here
43198 // void Bolt12ParseError_free(struct LDKBolt12ParseError this_obj);
43200 export function Bolt12ParseError_free(this_obj: bigint): void {
43201 if(!isWasmInitialized) {
43202 throw new Error("initializeWasm() must be awaited first!");
43204 const nativeResponseValue = wasm.TS_Bolt12ParseError_free(this_obj);
43205 // debug statements here
43207 // uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg);
43209 export function Bolt12ParseError_clone_ptr(arg: bigint): bigint {
43210 if(!isWasmInitialized) {
43211 throw new Error("initializeWasm() must be awaited first!");
43213 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone_ptr(arg);
43214 return nativeResponseValue;
43216 // struct LDKBolt12ParseError Bolt12ParseError_clone(const struct LDKBolt12ParseError *NONNULL_PTR orig);
43218 export function Bolt12ParseError_clone(orig: bigint): bigint {
43219 if(!isWasmInitialized) {
43220 throw new Error("initializeWasm() must be awaited first!");
43222 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone(orig);
43223 return nativeResponseValue;
43225 // enum LDKBolt12SemanticError Bolt12SemanticError_clone(const enum LDKBolt12SemanticError *NONNULL_PTR orig);
43227 export function Bolt12SemanticError_clone(orig: bigint): Bolt12SemanticError {
43228 if(!isWasmInitialized) {
43229 throw new Error("initializeWasm() must be awaited first!");
43231 const nativeResponseValue = wasm.TS_Bolt12SemanticError_clone(orig);
43232 return nativeResponseValue;
43234 // enum LDKBolt12SemanticError Bolt12SemanticError_already_expired(void);
43236 export function Bolt12SemanticError_already_expired(): Bolt12SemanticError {
43237 if(!isWasmInitialized) {
43238 throw new Error("initializeWasm() must be awaited first!");
43240 const nativeResponseValue = wasm.TS_Bolt12SemanticError_already_expired();
43241 return nativeResponseValue;
43243 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_chain(void);
43245 export function Bolt12SemanticError_unsupported_chain(): Bolt12SemanticError {
43246 if(!isWasmInitialized) {
43247 throw new Error("initializeWasm() must be awaited first!");
43249 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_chain();
43250 return nativeResponseValue;
43252 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_chain(void);
43254 export function Bolt12SemanticError_unexpected_chain(): Bolt12SemanticError {
43255 if(!isWasmInitialized) {
43256 throw new Error("initializeWasm() must be awaited first!");
43258 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_chain();
43259 return nativeResponseValue;
43261 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_amount(void);
43263 export function Bolt12SemanticError_missing_amount(): Bolt12SemanticError {
43264 if(!isWasmInitialized) {
43265 throw new Error("initializeWasm() must be awaited first!");
43267 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_amount();
43268 return nativeResponseValue;
43270 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_amount(void);
43272 export function Bolt12SemanticError_invalid_amount(): Bolt12SemanticError {
43273 if(!isWasmInitialized) {
43274 throw new Error("initializeWasm() must be awaited first!");
43276 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_amount();
43277 return nativeResponseValue;
43279 // enum LDKBolt12SemanticError Bolt12SemanticError_insufficient_amount(void);
43281 export function Bolt12SemanticError_insufficient_amount(): Bolt12SemanticError {
43282 if(!isWasmInitialized) {
43283 throw new Error("initializeWasm() must be awaited first!");
43285 const nativeResponseValue = wasm.TS_Bolt12SemanticError_insufficient_amount();
43286 return nativeResponseValue;
43288 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_amount(void);
43290 export function Bolt12SemanticError_unexpected_amount(): Bolt12SemanticError {
43291 if(!isWasmInitialized) {
43292 throw new Error("initializeWasm() must be awaited first!");
43294 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_amount();
43295 return nativeResponseValue;
43297 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_currency(void);
43299 export function Bolt12SemanticError_unsupported_currency(): Bolt12SemanticError {
43300 if(!isWasmInitialized) {
43301 throw new Error("initializeWasm() must be awaited first!");
43303 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_currency();
43304 return nativeResponseValue;
43306 // enum LDKBolt12SemanticError Bolt12SemanticError_unknown_required_features(void);
43308 export function Bolt12SemanticError_unknown_required_features(): Bolt12SemanticError {
43309 if(!isWasmInitialized) {
43310 throw new Error("initializeWasm() must be awaited first!");
43312 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unknown_required_features();
43313 return nativeResponseValue;
43315 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_features(void);
43317 export function Bolt12SemanticError_unexpected_features(): Bolt12SemanticError {
43318 if(!isWasmInitialized) {
43319 throw new Error("initializeWasm() must be awaited first!");
43321 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_features();
43322 return nativeResponseValue;
43324 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_description(void);
43326 export function Bolt12SemanticError_missing_description(): Bolt12SemanticError {
43327 if(!isWasmInitialized) {
43328 throw new Error("initializeWasm() must be awaited first!");
43330 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_description();
43331 return nativeResponseValue;
43333 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signing_pubkey(void);
43335 export function Bolt12SemanticError_missing_signing_pubkey(): Bolt12SemanticError {
43336 if(!isWasmInitialized) {
43337 throw new Error("initializeWasm() must be awaited first!");
43339 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signing_pubkey();
43340 return nativeResponseValue;
43342 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_signing_pubkey(void);
43344 export function Bolt12SemanticError_invalid_signing_pubkey(): Bolt12SemanticError {
43345 if(!isWasmInitialized) {
43346 throw new Error("initializeWasm() must be awaited first!");
43348 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_signing_pubkey();
43349 return nativeResponseValue;
43351 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_signing_pubkey(void);
43353 export function Bolt12SemanticError_unexpected_signing_pubkey(): Bolt12SemanticError {
43354 if(!isWasmInitialized) {
43355 throw new Error("initializeWasm() must be awaited first!");
43357 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_signing_pubkey();
43358 return nativeResponseValue;
43360 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_quantity(void);
43362 export function Bolt12SemanticError_missing_quantity(): Bolt12SemanticError {
43363 if(!isWasmInitialized) {
43364 throw new Error("initializeWasm() must be awaited first!");
43366 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_quantity();
43367 return nativeResponseValue;
43369 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_quantity(void);
43371 export function Bolt12SemanticError_invalid_quantity(): Bolt12SemanticError {
43372 if(!isWasmInitialized) {
43373 throw new Error("initializeWasm() must be awaited first!");
43375 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_quantity();
43376 return nativeResponseValue;
43378 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_quantity(void);
43380 export function Bolt12SemanticError_unexpected_quantity(): Bolt12SemanticError {
43381 if(!isWasmInitialized) {
43382 throw new Error("initializeWasm() must be awaited first!");
43384 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_quantity();
43385 return nativeResponseValue;
43387 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_metadata(void);
43389 export function Bolt12SemanticError_invalid_metadata(): Bolt12SemanticError {
43390 if(!isWasmInitialized) {
43391 throw new Error("initializeWasm() must be awaited first!");
43393 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_metadata();
43394 return nativeResponseValue;
43396 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_metadata(void);
43398 export function Bolt12SemanticError_unexpected_metadata(): Bolt12SemanticError {
43399 if(!isWasmInitialized) {
43400 throw new Error("initializeWasm() must be awaited first!");
43402 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_metadata();
43403 return nativeResponseValue;
43405 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_metadata(void);
43407 export function Bolt12SemanticError_missing_payer_metadata(): Bolt12SemanticError {
43408 if(!isWasmInitialized) {
43409 throw new Error("initializeWasm() must be awaited first!");
43411 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_metadata();
43412 return nativeResponseValue;
43414 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_id(void);
43416 export function Bolt12SemanticError_missing_payer_id(): Bolt12SemanticError {
43417 if(!isWasmInitialized) {
43418 throw new Error("initializeWasm() must be awaited first!");
43420 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_id();
43421 return nativeResponseValue;
43423 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_paths(void);
43425 export function Bolt12SemanticError_missing_paths(): Bolt12SemanticError {
43426 if(!isWasmInitialized) {
43427 throw new Error("initializeWasm() must be awaited first!");
43429 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_paths();
43430 return nativeResponseValue;
43432 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_pay_info(void);
43434 export function Bolt12SemanticError_invalid_pay_info(): Bolt12SemanticError {
43435 if(!isWasmInitialized) {
43436 throw new Error("initializeWasm() must be awaited first!");
43438 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_pay_info();
43439 return nativeResponseValue;
43441 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_creation_time(void);
43443 export function Bolt12SemanticError_missing_creation_time(): Bolt12SemanticError {
43444 if(!isWasmInitialized) {
43445 throw new Error("initializeWasm() must be awaited first!");
43447 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_creation_time();
43448 return nativeResponseValue;
43450 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payment_hash(void);
43452 export function Bolt12SemanticError_missing_payment_hash(): Bolt12SemanticError {
43453 if(!isWasmInitialized) {
43454 throw new Error("initializeWasm() must be awaited first!");
43456 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payment_hash();
43457 return nativeResponseValue;
43459 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signature(void);
43461 export function Bolt12SemanticError_missing_signature(): Bolt12SemanticError {
43462 if(!isWasmInitialized) {
43463 throw new Error("initializeWasm() must be awaited first!");
43465 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signature();
43466 return nativeResponseValue;
43468 // void Refund_free(struct LDKRefund this_obj);
43470 export function Refund_free(this_obj: bigint): void {
43471 if(!isWasmInitialized) {
43472 throw new Error("initializeWasm() must be awaited first!");
43474 const nativeResponseValue = wasm.TS_Refund_free(this_obj);
43475 // debug statements here
43477 // uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
43479 export function Refund_clone_ptr(arg: bigint): bigint {
43480 if(!isWasmInitialized) {
43481 throw new Error("initializeWasm() must be awaited first!");
43483 const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
43484 return nativeResponseValue;
43486 // struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
43488 export function Refund_clone(orig: bigint): bigint {
43489 if(!isWasmInitialized) {
43490 throw new Error("initializeWasm() must be awaited first!");
43492 const nativeResponseValue = wasm.TS_Refund_clone(orig);
43493 return nativeResponseValue;
43495 // MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
43497 export function Refund_description(this_arg: bigint): bigint {
43498 if(!isWasmInitialized) {
43499 throw new Error("initializeWasm() must be awaited first!");
43501 const nativeResponseValue = wasm.TS_Refund_description(this_arg);
43502 return nativeResponseValue;
43504 // MUST_USE_RES struct LDKCOption_u64Z Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
43506 export function Refund_absolute_expiry(this_arg: bigint): bigint {
43507 if(!isWasmInitialized) {
43508 throw new Error("initializeWasm() must be awaited first!");
43510 const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
43511 return nativeResponseValue;
43513 // MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
43515 export function Refund_issuer(this_arg: bigint): bigint {
43516 if(!isWasmInitialized) {
43517 throw new Error("initializeWasm() must be awaited first!");
43519 const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
43520 return nativeResponseValue;
43522 // MUST_USE_RES struct LDKCVec_BlindedPathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
43524 export function Refund_paths(this_arg: bigint): number {
43525 if(!isWasmInitialized) {
43526 throw new Error("initializeWasm() must be awaited first!");
43528 const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
43529 return nativeResponseValue;
43531 // MUST_USE_RES struct LDKu8slice Refund_payer_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
43533 export function Refund_payer_metadata(this_arg: bigint): number {
43534 if(!isWasmInitialized) {
43535 throw new Error("initializeWasm() must be awaited first!");
43537 const nativeResponseValue = wasm.TS_Refund_payer_metadata(this_arg);
43538 return nativeResponseValue;
43540 // MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
43542 export function Refund_chain(this_arg: bigint): number {
43543 if(!isWasmInitialized) {
43544 throw new Error("initializeWasm() must be awaited first!");
43546 const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
43547 return nativeResponseValue;
43549 // MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
43551 export function Refund_amount_msats(this_arg: bigint): bigint {
43552 if(!isWasmInitialized) {
43553 throw new Error("initializeWasm() must be awaited first!");
43555 const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
43556 return nativeResponseValue;
43558 // MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
43560 export function Refund_features(this_arg: bigint): bigint {
43561 if(!isWasmInitialized) {
43562 throw new Error("initializeWasm() must be awaited first!");
43564 const nativeResponseValue = wasm.TS_Refund_features(this_arg);
43565 return nativeResponseValue;
43567 // MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
43569 export function Refund_quantity(this_arg: bigint): bigint {
43570 if(!isWasmInitialized) {
43571 throw new Error("initializeWasm() must be awaited first!");
43573 const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
43574 return nativeResponseValue;
43576 // MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
43578 export function Refund_payer_id(this_arg: bigint): number {
43579 if(!isWasmInitialized) {
43580 throw new Error("initializeWasm() must be awaited first!");
43582 const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
43583 return nativeResponseValue;
43585 // MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
43587 export function Refund_payer_note(this_arg: bigint): bigint {
43588 if(!isWasmInitialized) {
43589 throw new Error("initializeWasm() must be awaited first!");
43591 const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
43592 return nativeResponseValue;
43594 // struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
43596 export function Refund_write(obj: bigint): number {
43597 if(!isWasmInitialized) {
43598 throw new Error("initializeWasm() must be awaited first!");
43600 const nativeResponseValue = wasm.TS_Refund_write(obj);
43601 return nativeResponseValue;
43603 // struct LDKCResult_RefundBolt12ParseErrorZ Refund_from_str(struct LDKStr s);
43605 export function Refund_from_str(s: number): bigint {
43606 if(!isWasmInitialized) {
43607 throw new Error("initializeWasm() must be awaited first!");
43609 const nativeResponseValue = wasm.TS_Refund_from_str(s);
43610 return nativeResponseValue;
43612 // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
43614 export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
43615 if(!isWasmInitialized) {
43616 throw new Error("initializeWasm() must be awaited first!");
43618 const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
43619 return nativeResponseValue;
43621 // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
43623 export function UtxoLookupError_unknown_chain(): UtxoLookupError {
43624 if(!isWasmInitialized) {
43625 throw new Error("initializeWasm() must be awaited first!");
43627 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
43628 return nativeResponseValue;
43630 // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
43632 export function UtxoLookupError_unknown_tx(): UtxoLookupError {
43633 if(!isWasmInitialized) {
43634 throw new Error("initializeWasm() must be awaited first!");
43636 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
43637 return nativeResponseValue;
43639 // void UtxoResult_free(struct LDKUtxoResult this_ptr);
43641 export function UtxoResult_free(this_ptr: bigint): void {
43642 if(!isWasmInitialized) {
43643 throw new Error("initializeWasm() must be awaited first!");
43645 const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
43646 // debug statements here
43648 // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
43650 export function UtxoResult_clone_ptr(arg: bigint): bigint {
43651 if(!isWasmInitialized) {
43652 throw new Error("initializeWasm() must be awaited first!");
43654 const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
43655 return nativeResponseValue;
43657 // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
43659 export function UtxoResult_clone(orig: bigint): bigint {
43660 if(!isWasmInitialized) {
43661 throw new Error("initializeWasm() must be awaited first!");
43663 const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
43664 return nativeResponseValue;
43666 // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
43668 export function UtxoResult_sync(a: bigint): bigint {
43669 if(!isWasmInitialized) {
43670 throw new Error("initializeWasm() must be awaited first!");
43672 const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
43673 return nativeResponseValue;
43675 // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
43677 export function UtxoResult_async(a: bigint): bigint {
43678 if(!isWasmInitialized) {
43679 throw new Error("initializeWasm() must be awaited first!");
43681 const nativeResponseValue = wasm.TS_UtxoResult_async(a);
43682 return nativeResponseValue;
43684 // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
43686 export function UtxoLookup_free(this_ptr: bigint): void {
43687 if(!isWasmInitialized) {
43688 throw new Error("initializeWasm() must be awaited first!");
43690 const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
43691 // debug statements here
43693 // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
43695 export function UtxoFuture_free(this_obj: bigint): void {
43696 if(!isWasmInitialized) {
43697 throw new Error("initializeWasm() must be awaited first!");
43699 const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
43700 // debug statements here
43702 // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
43704 export function UtxoFuture_clone_ptr(arg: bigint): bigint {
43705 if(!isWasmInitialized) {
43706 throw new Error("initializeWasm() must be awaited first!");
43708 const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
43709 return nativeResponseValue;
43711 // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
43713 export function UtxoFuture_clone(orig: bigint): bigint {
43714 if(!isWasmInitialized) {
43715 throw new Error("initializeWasm() must be awaited first!");
43717 const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
43718 return nativeResponseValue;
43720 // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
43722 export function UtxoFuture_new(): bigint {
43723 if(!isWasmInitialized) {
43724 throw new Error("initializeWasm() must be awaited first!");
43726 const nativeResponseValue = wasm.TS_UtxoFuture_new();
43727 return nativeResponseValue;
43729 // void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
43731 export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
43732 if(!isWasmInitialized) {
43733 throw new Error("initializeWasm() must be awaited first!");
43735 const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
43736 // debug statements here
43738 // 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);
43740 export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
43741 if(!isWasmInitialized) {
43742 throw new Error("initializeWasm() must be awaited first!");
43744 const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
43745 // debug statements here
43747 // void NodeId_free(struct LDKNodeId this_obj);
43749 export function NodeId_free(this_obj: bigint): void {
43750 if(!isWasmInitialized) {
43751 throw new Error("initializeWasm() must be awaited first!");
43753 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
43754 // debug statements here
43756 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
43758 export function NodeId_clone_ptr(arg: bigint): bigint {
43759 if(!isWasmInitialized) {
43760 throw new Error("initializeWasm() must be awaited first!");
43762 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
43763 return nativeResponseValue;
43765 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
43767 export function NodeId_clone(orig: bigint): bigint {
43768 if(!isWasmInitialized) {
43769 throw new Error("initializeWasm() must be awaited first!");
43771 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
43772 return nativeResponseValue;
43774 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
43776 export function NodeId_from_pubkey(pubkey: number): bigint {
43777 if(!isWasmInitialized) {
43778 throw new Error("initializeWasm() must be awaited first!");
43780 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
43781 return nativeResponseValue;
43783 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
43785 export function NodeId_as_slice(this_arg: bigint): number {
43786 if(!isWasmInitialized) {
43787 throw new Error("initializeWasm() must be awaited first!");
43789 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
43790 return nativeResponseValue;
43792 // MUST_USE_RES struct LDKCResult_PublicKeySecp256k1ErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
43794 export function NodeId_as_pubkey(this_arg: bigint): bigint {
43795 if(!isWasmInitialized) {
43796 throw new Error("initializeWasm() must be awaited first!");
43798 const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
43799 return nativeResponseValue;
43801 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
43803 export function NodeId_hash(o: bigint): bigint {
43804 if(!isWasmInitialized) {
43805 throw new Error("initializeWasm() must be awaited first!");
43807 const nativeResponseValue = wasm.TS_NodeId_hash(o);
43808 return nativeResponseValue;
43810 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
43812 export function NodeId_write(obj: bigint): number {
43813 if(!isWasmInitialized) {
43814 throw new Error("initializeWasm() must be awaited first!");
43816 const nativeResponseValue = wasm.TS_NodeId_write(obj);
43817 return nativeResponseValue;
43819 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
43821 export function NodeId_read(ser: number): bigint {
43822 if(!isWasmInitialized) {
43823 throw new Error("initializeWasm() must be awaited first!");
43825 const nativeResponseValue = wasm.TS_NodeId_read(ser);
43826 return nativeResponseValue;
43828 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
43830 export function NetworkGraph_free(this_obj: bigint): void {
43831 if(!isWasmInitialized) {
43832 throw new Error("initializeWasm() must be awaited first!");
43834 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
43835 // debug statements here
43837 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
43839 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
43840 if(!isWasmInitialized) {
43841 throw new Error("initializeWasm() must be awaited first!");
43843 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
43844 // debug statements here
43846 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
43848 export function NetworkUpdate_free(this_ptr: bigint): void {
43849 if(!isWasmInitialized) {
43850 throw new Error("initializeWasm() must be awaited first!");
43852 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
43853 // debug statements here
43855 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
43857 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
43858 if(!isWasmInitialized) {
43859 throw new Error("initializeWasm() must be awaited first!");
43861 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
43862 return nativeResponseValue;
43864 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
43866 export function NetworkUpdate_clone(orig: bigint): bigint {
43867 if(!isWasmInitialized) {
43868 throw new Error("initializeWasm() must be awaited first!");
43870 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
43871 return nativeResponseValue;
43873 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
43875 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
43876 if(!isWasmInitialized) {
43877 throw new Error("initializeWasm() must be awaited first!");
43879 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
43880 return nativeResponseValue;
43882 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
43884 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
43885 if(!isWasmInitialized) {
43886 throw new Error("initializeWasm() must be awaited first!");
43888 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
43889 return nativeResponseValue;
43891 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
43893 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
43894 if(!isWasmInitialized) {
43895 throw new Error("initializeWasm() must be awaited first!");
43897 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
43898 return nativeResponseValue;
43900 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
43902 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
43903 if(!isWasmInitialized) {
43904 throw new Error("initializeWasm() must be awaited first!");
43906 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
43907 return nativeResponseValue;
43909 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
43911 export function NetworkUpdate_write(obj: bigint): number {
43912 if(!isWasmInitialized) {
43913 throw new Error("initializeWasm() must be awaited first!");
43915 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
43916 return nativeResponseValue;
43918 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
43920 export function NetworkUpdate_read(ser: number): bigint {
43921 if(!isWasmInitialized) {
43922 throw new Error("initializeWasm() must be awaited first!");
43924 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
43925 return nativeResponseValue;
43927 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
43929 export function P2PGossipSync_free(this_obj: bigint): void {
43930 if(!isWasmInitialized) {
43931 throw new Error("initializeWasm() must be awaited first!");
43933 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
43934 // debug statements here
43936 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
43938 export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
43939 if(!isWasmInitialized) {
43940 throw new Error("initializeWasm() must be awaited first!");
43942 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
43943 return nativeResponseValue;
43945 // void P2PGossipSync_add_utxo_lookup(const struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
43947 export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
43948 if(!isWasmInitialized) {
43949 throw new Error("initializeWasm() must be awaited first!");
43951 const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
43952 // debug statements here
43954 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
43956 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
43957 if(!isWasmInitialized) {
43958 throw new Error("initializeWasm() must be awaited first!");
43960 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
43961 // debug statements here
43963 // MUST_USE_RES struct LDKThirtyTwoBytes NetworkGraph_get_genesis_hash(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
43965 export function NetworkGraph_get_genesis_hash(this_arg: bigint): number {
43966 if(!isWasmInitialized) {
43967 throw new Error("initializeWasm() must be awaited first!");
43969 const nativeResponseValue = wasm.TS_NetworkGraph_get_genesis_hash(this_arg);
43970 return nativeResponseValue;
43972 // struct LDKCResult_NoneLightningErrorZ verify_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
43974 export function verify_node_announcement(msg: bigint): bigint {
43975 if(!isWasmInitialized) {
43976 throw new Error("initializeWasm() must be awaited first!");
43978 const nativeResponseValue = wasm.TS_verify_node_announcement(msg);
43979 return nativeResponseValue;
43981 // struct LDKCResult_NoneLightningErrorZ verify_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
43983 export function verify_channel_announcement(msg: bigint): bigint {
43984 if(!isWasmInitialized) {
43985 throw new Error("initializeWasm() must be awaited first!");
43987 const nativeResponseValue = wasm.TS_verify_channel_announcement(msg);
43988 return nativeResponseValue;
43990 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
43992 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
43993 if(!isWasmInitialized) {
43994 throw new Error("initializeWasm() must be awaited first!");
43996 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
43997 return nativeResponseValue;
43999 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
44001 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
44002 if(!isWasmInitialized) {
44003 throw new Error("initializeWasm() must be awaited first!");
44005 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
44006 return nativeResponseValue;
44008 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
44010 export function ChannelUpdateInfo_free(this_obj: bigint): void {
44011 if(!isWasmInitialized) {
44012 throw new Error("initializeWasm() must be awaited first!");
44014 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
44015 // debug statements here
44017 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44019 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
44020 if(!isWasmInitialized) {
44021 throw new Error("initializeWasm() must be awaited first!");
44023 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
44024 return nativeResponseValue;
44026 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
44028 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
44029 if(!isWasmInitialized) {
44030 throw new Error("initializeWasm() must be awaited first!");
44032 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
44033 // debug statements here
44035 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44037 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
44038 if(!isWasmInitialized) {
44039 throw new Error("initializeWasm() must be awaited first!");
44041 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
44042 return nativeResponseValue;
44044 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
44046 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
44047 if(!isWasmInitialized) {
44048 throw new Error("initializeWasm() must be awaited first!");
44050 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
44051 // debug statements here
44053 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44055 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
44056 if(!isWasmInitialized) {
44057 throw new Error("initializeWasm() must be awaited first!");
44059 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
44060 return nativeResponseValue;
44062 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
44064 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
44065 if(!isWasmInitialized) {
44066 throw new Error("initializeWasm() must be awaited first!");
44068 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
44069 // debug statements here
44071 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44073 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
44074 if(!isWasmInitialized) {
44075 throw new Error("initializeWasm() must be awaited first!");
44077 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
44078 return nativeResponseValue;
44080 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
44082 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
44083 if(!isWasmInitialized) {
44084 throw new Error("initializeWasm() must be awaited first!");
44086 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
44087 // debug statements here
44089 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44091 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
44092 if(!isWasmInitialized) {
44093 throw new Error("initializeWasm() must be awaited first!");
44095 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
44096 return nativeResponseValue;
44098 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
44100 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
44101 if(!isWasmInitialized) {
44102 throw new Error("initializeWasm() must be awaited first!");
44104 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
44105 // debug statements here
44107 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44109 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
44110 if(!isWasmInitialized) {
44111 throw new Error("initializeWasm() must be awaited first!");
44113 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
44114 return nativeResponseValue;
44116 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
44118 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
44119 if(!isWasmInitialized) {
44120 throw new Error("initializeWasm() must be awaited first!");
44122 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
44123 // debug statements here
44125 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44127 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
44128 if(!isWasmInitialized) {
44129 throw new Error("initializeWasm() must be awaited first!");
44131 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
44132 return nativeResponseValue;
44134 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
44136 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
44137 if(!isWasmInitialized) {
44138 throw new Error("initializeWasm() must be awaited first!");
44140 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
44141 // debug statements here
44143 // 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);
44145 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 {
44146 if(!isWasmInitialized) {
44147 throw new Error("initializeWasm() must be awaited first!");
44149 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);
44150 return nativeResponseValue;
44152 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
44154 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
44155 if(!isWasmInitialized) {
44156 throw new Error("initializeWasm() must be awaited first!");
44158 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
44159 return nativeResponseValue;
44161 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
44163 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
44164 if(!isWasmInitialized) {
44165 throw new Error("initializeWasm() must be awaited first!");
44167 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
44168 return nativeResponseValue;
44170 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
44172 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
44173 if(!isWasmInitialized) {
44174 throw new Error("initializeWasm() must be awaited first!");
44176 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
44177 return nativeResponseValue;
44179 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
44181 export function ChannelUpdateInfo_write(obj: bigint): number {
44182 if(!isWasmInitialized) {
44183 throw new Error("initializeWasm() must be awaited first!");
44185 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
44186 return nativeResponseValue;
44188 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
44190 export function ChannelUpdateInfo_read(ser: number): bigint {
44191 if(!isWasmInitialized) {
44192 throw new Error("initializeWasm() must be awaited first!");
44194 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
44195 return nativeResponseValue;
44197 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
44199 export function ChannelInfo_free(this_obj: bigint): void {
44200 if(!isWasmInitialized) {
44201 throw new Error("initializeWasm() must be awaited first!");
44203 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
44204 // debug statements here
44206 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44208 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
44209 if(!isWasmInitialized) {
44210 throw new Error("initializeWasm() must be awaited first!");
44212 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
44213 return nativeResponseValue;
44215 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
44217 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
44218 if(!isWasmInitialized) {
44219 throw new Error("initializeWasm() must be awaited first!");
44221 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
44222 // debug statements here
44224 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44226 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
44227 if(!isWasmInitialized) {
44228 throw new Error("initializeWasm() must be awaited first!");
44230 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
44231 return nativeResponseValue;
44233 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
44235 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
44236 if(!isWasmInitialized) {
44237 throw new Error("initializeWasm() must be awaited first!");
44239 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
44240 // debug statements here
44242 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44244 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
44245 if(!isWasmInitialized) {
44246 throw new Error("initializeWasm() must be awaited first!");
44248 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
44249 return nativeResponseValue;
44251 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
44253 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
44254 if(!isWasmInitialized) {
44255 throw new Error("initializeWasm() must be awaited first!");
44257 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
44258 // debug statements here
44260 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44262 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
44263 if(!isWasmInitialized) {
44264 throw new Error("initializeWasm() must be awaited first!");
44266 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
44267 return nativeResponseValue;
44269 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
44271 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
44272 if(!isWasmInitialized) {
44273 throw new Error("initializeWasm() must be awaited first!");
44275 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
44276 // debug statements here
44278 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44280 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
44281 if(!isWasmInitialized) {
44282 throw new Error("initializeWasm() must be awaited first!");
44284 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
44285 return nativeResponseValue;
44287 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
44289 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
44290 if(!isWasmInitialized) {
44291 throw new Error("initializeWasm() must be awaited first!");
44293 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
44294 // debug statements here
44296 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44298 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
44299 if(!isWasmInitialized) {
44300 throw new Error("initializeWasm() must be awaited first!");
44302 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
44303 return nativeResponseValue;
44305 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
44307 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
44308 if(!isWasmInitialized) {
44309 throw new Error("initializeWasm() must be awaited first!");
44311 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
44312 // debug statements here
44314 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44316 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
44317 if(!isWasmInitialized) {
44318 throw new Error("initializeWasm() must be awaited first!");
44320 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
44321 return nativeResponseValue;
44323 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
44325 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
44326 if(!isWasmInitialized) {
44327 throw new Error("initializeWasm() must be awaited first!");
44329 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
44330 // debug statements here
44332 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
44334 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
44335 if(!isWasmInitialized) {
44336 throw new Error("initializeWasm() must be awaited first!");
44338 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
44339 return nativeResponseValue;
44341 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
44343 export function ChannelInfo_clone(orig: bigint): bigint {
44344 if(!isWasmInitialized) {
44345 throw new Error("initializeWasm() must be awaited first!");
44347 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
44348 return nativeResponseValue;
44350 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
44352 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
44353 if(!isWasmInitialized) {
44354 throw new Error("initializeWasm() must be awaited first!");
44356 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
44357 return nativeResponseValue;
44359 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
44361 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
44362 if(!isWasmInitialized) {
44363 throw new Error("initializeWasm() must be awaited first!");
44365 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
44366 return nativeResponseValue;
44368 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
44370 export function ChannelInfo_write(obj: bigint): number {
44371 if(!isWasmInitialized) {
44372 throw new Error("initializeWasm() must be awaited first!");
44374 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
44375 return nativeResponseValue;
44377 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
44379 export function ChannelInfo_read(ser: number): bigint {
44380 if(!isWasmInitialized) {
44381 throw new Error("initializeWasm() must be awaited first!");
44383 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
44384 return nativeResponseValue;
44386 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
44388 export function DirectedChannelInfo_free(this_obj: bigint): void {
44389 if(!isWasmInitialized) {
44390 throw new Error("initializeWasm() must be awaited first!");
44392 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
44393 // debug statements here
44395 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
44397 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
44398 if(!isWasmInitialized) {
44399 throw new Error("initializeWasm() must be awaited first!");
44401 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
44402 return nativeResponseValue;
44404 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
44406 export function DirectedChannelInfo_clone(orig: bigint): bigint {
44407 if(!isWasmInitialized) {
44408 throw new Error("initializeWasm() must be awaited first!");
44410 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
44411 return nativeResponseValue;
44413 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
44415 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
44416 if(!isWasmInitialized) {
44417 throw new Error("initializeWasm() must be awaited first!");
44419 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
44420 return nativeResponseValue;
44422 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
44424 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
44425 if(!isWasmInitialized) {
44426 throw new Error("initializeWasm() must be awaited first!");
44428 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
44429 return nativeResponseValue;
44431 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
44433 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
44434 if(!isWasmInitialized) {
44435 throw new Error("initializeWasm() must be awaited first!");
44437 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
44438 return nativeResponseValue;
44440 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
44442 export function EffectiveCapacity_free(this_ptr: bigint): void {
44443 if(!isWasmInitialized) {
44444 throw new Error("initializeWasm() must be awaited first!");
44446 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
44447 // debug statements here
44449 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
44451 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
44452 if(!isWasmInitialized) {
44453 throw new Error("initializeWasm() must be awaited first!");
44455 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
44456 return nativeResponseValue;
44458 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
44460 export function EffectiveCapacity_clone(orig: bigint): bigint {
44461 if(!isWasmInitialized) {
44462 throw new Error("initializeWasm() must be awaited first!");
44464 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
44465 return nativeResponseValue;
44467 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
44469 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
44470 if(!isWasmInitialized) {
44471 throw new Error("initializeWasm() must be awaited first!");
44473 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
44474 return nativeResponseValue;
44476 // struct LDKEffectiveCapacity EffectiveCapacity_advertised_max_htlc(uint64_t amount_msat);
44478 export function EffectiveCapacity_advertised_max_htlc(amount_msat: bigint): bigint {
44479 if(!isWasmInitialized) {
44480 throw new Error("initializeWasm() must be awaited first!");
44482 const nativeResponseValue = wasm.TS_EffectiveCapacity_advertised_max_htlc(amount_msat);
44483 return nativeResponseValue;
44485 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
44487 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
44488 if(!isWasmInitialized) {
44489 throw new Error("initializeWasm() must be awaited first!");
44491 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
44492 return nativeResponseValue;
44494 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
44496 export function EffectiveCapacity_infinite(): bigint {
44497 if(!isWasmInitialized) {
44498 throw new Error("initializeWasm() must be awaited first!");
44500 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
44501 return nativeResponseValue;
44503 // struct LDKEffectiveCapacity EffectiveCapacity_hint_max_htlc(uint64_t amount_msat);
44505 export function EffectiveCapacity_hint_max_htlc(amount_msat: bigint): bigint {
44506 if(!isWasmInitialized) {
44507 throw new Error("initializeWasm() must be awaited first!");
44509 const nativeResponseValue = wasm.TS_EffectiveCapacity_hint_max_htlc(amount_msat);
44510 return nativeResponseValue;
44512 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
44514 export function EffectiveCapacity_unknown(): bigint {
44515 if(!isWasmInitialized) {
44516 throw new Error("initializeWasm() must be awaited first!");
44518 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
44519 return nativeResponseValue;
44521 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
44523 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
44524 if(!isWasmInitialized) {
44525 throw new Error("initializeWasm() must be awaited first!");
44527 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
44528 return nativeResponseValue;
44530 // void RoutingFees_free(struct LDKRoutingFees this_obj);
44532 export function RoutingFees_free(this_obj: bigint): void {
44533 if(!isWasmInitialized) {
44534 throw new Error("initializeWasm() must be awaited first!");
44536 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
44537 // debug statements here
44539 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
44541 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
44542 if(!isWasmInitialized) {
44543 throw new Error("initializeWasm() must be awaited first!");
44545 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
44546 return nativeResponseValue;
44548 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
44550 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
44551 if(!isWasmInitialized) {
44552 throw new Error("initializeWasm() must be awaited first!");
44554 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
44555 // debug statements here
44557 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
44559 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
44560 if(!isWasmInitialized) {
44561 throw new Error("initializeWasm() must be awaited first!");
44563 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
44564 return nativeResponseValue;
44566 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
44568 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
44569 if(!isWasmInitialized) {
44570 throw new Error("initializeWasm() must be awaited first!");
44572 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
44573 // debug statements here
44575 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
44577 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
44578 if(!isWasmInitialized) {
44579 throw new Error("initializeWasm() must be awaited first!");
44581 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
44582 return nativeResponseValue;
44584 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
44586 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
44587 if(!isWasmInitialized) {
44588 throw new Error("initializeWasm() must be awaited first!");
44590 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
44591 return nativeResponseValue;
44593 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
44595 export function RoutingFees_clone_ptr(arg: bigint): bigint {
44596 if(!isWasmInitialized) {
44597 throw new Error("initializeWasm() must be awaited first!");
44599 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
44600 return nativeResponseValue;
44602 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
44604 export function RoutingFees_clone(orig: bigint): bigint {
44605 if(!isWasmInitialized) {
44606 throw new Error("initializeWasm() must be awaited first!");
44608 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
44609 return nativeResponseValue;
44611 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
44613 export function RoutingFees_hash(o: bigint): bigint {
44614 if(!isWasmInitialized) {
44615 throw new Error("initializeWasm() must be awaited first!");
44617 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
44618 return nativeResponseValue;
44620 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
44622 export function RoutingFees_write(obj: bigint): number {
44623 if(!isWasmInitialized) {
44624 throw new Error("initializeWasm() must be awaited first!");
44626 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
44627 return nativeResponseValue;
44629 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
44631 export function RoutingFees_read(ser: number): bigint {
44632 if(!isWasmInitialized) {
44633 throw new Error("initializeWasm() must be awaited first!");
44635 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
44636 return nativeResponseValue;
44638 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
44640 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
44641 if(!isWasmInitialized) {
44642 throw new Error("initializeWasm() must be awaited first!");
44644 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
44645 // debug statements here
44647 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
44649 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
44650 if(!isWasmInitialized) {
44651 throw new Error("initializeWasm() must be awaited first!");
44653 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
44654 return nativeResponseValue;
44656 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
44658 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
44659 if(!isWasmInitialized) {
44660 throw new Error("initializeWasm() must be awaited first!");
44662 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
44663 // debug statements here
44665 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
44667 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
44668 if(!isWasmInitialized) {
44669 throw new Error("initializeWasm() must be awaited first!");
44671 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
44672 return nativeResponseValue;
44674 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
44676 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
44677 if(!isWasmInitialized) {
44678 throw new Error("initializeWasm() must be awaited first!");
44680 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
44681 // debug statements here
44683 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
44685 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
44686 if(!isWasmInitialized) {
44687 throw new Error("initializeWasm() must be awaited first!");
44689 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
44690 return nativeResponseValue;
44692 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
44694 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
44695 if(!isWasmInitialized) {
44696 throw new Error("initializeWasm() must be awaited first!");
44698 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
44699 // debug statements here
44701 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
44703 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
44704 if(!isWasmInitialized) {
44705 throw new Error("initializeWasm() must be awaited first!");
44707 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
44708 return nativeResponseValue;
44710 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
44712 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
44713 if(!isWasmInitialized) {
44714 throw new Error("initializeWasm() must be awaited first!");
44716 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
44717 // debug statements here
44719 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
44721 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
44722 if(!isWasmInitialized) {
44723 throw new Error("initializeWasm() must be awaited first!");
44725 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
44726 return nativeResponseValue;
44728 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
44730 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
44731 if(!isWasmInitialized) {
44732 throw new Error("initializeWasm() must be awaited first!");
44734 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
44735 // debug statements here
44737 // 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);
44739 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, announcement_message_arg: bigint): bigint {
44740 if(!isWasmInitialized) {
44741 throw new Error("initializeWasm() must be awaited first!");
44743 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, announcement_message_arg);
44744 return nativeResponseValue;
44746 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
44748 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
44749 if(!isWasmInitialized) {
44750 throw new Error("initializeWasm() must be awaited first!");
44752 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
44753 return nativeResponseValue;
44755 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
44757 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
44758 if(!isWasmInitialized) {
44759 throw new Error("initializeWasm() must be awaited first!");
44761 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
44762 return nativeResponseValue;
44764 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
44766 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
44767 if(!isWasmInitialized) {
44768 throw new Error("initializeWasm() must be awaited first!");
44770 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
44771 return nativeResponseValue;
44773 // MUST_USE_RES struct LDKCVec_SocketAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
44775 export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
44776 if(!isWasmInitialized) {
44777 throw new Error("initializeWasm() must be awaited first!");
44779 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
44780 return nativeResponseValue;
44782 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
44784 export function NodeAnnouncementInfo_write(obj: bigint): number {
44785 if(!isWasmInitialized) {
44786 throw new Error("initializeWasm() must be awaited first!");
44788 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
44789 return nativeResponseValue;
44791 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
44793 export function NodeAnnouncementInfo_read(ser: number): bigint {
44794 if(!isWasmInitialized) {
44795 throw new Error("initializeWasm() must be awaited first!");
44797 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
44798 return nativeResponseValue;
44800 // void NodeAlias_free(struct LDKNodeAlias this_obj);
44802 export function NodeAlias_free(this_obj: bigint): void {
44803 if(!isWasmInitialized) {
44804 throw new Error("initializeWasm() must be awaited first!");
44806 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
44807 // debug statements here
44809 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
44811 export function NodeAlias_get_a(this_ptr: bigint): number {
44812 if(!isWasmInitialized) {
44813 throw new Error("initializeWasm() must be awaited first!");
44815 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
44816 return nativeResponseValue;
44818 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
44820 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
44821 if(!isWasmInitialized) {
44822 throw new Error("initializeWasm() must be awaited first!");
44824 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
44825 // debug statements here
44827 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
44829 export function NodeAlias_new(a_arg: number): bigint {
44830 if(!isWasmInitialized) {
44831 throw new Error("initializeWasm() must be awaited first!");
44833 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
44834 return nativeResponseValue;
44836 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
44838 export function NodeAlias_clone_ptr(arg: bigint): bigint {
44839 if(!isWasmInitialized) {
44840 throw new Error("initializeWasm() must be awaited first!");
44842 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
44843 return nativeResponseValue;
44845 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
44847 export function NodeAlias_clone(orig: bigint): bigint {
44848 if(!isWasmInitialized) {
44849 throw new Error("initializeWasm() must be awaited first!");
44851 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
44852 return nativeResponseValue;
44854 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
44856 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
44857 if(!isWasmInitialized) {
44858 throw new Error("initializeWasm() must be awaited first!");
44860 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
44861 return nativeResponseValue;
44863 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
44865 export function NodeAlias_write(obj: bigint): number {
44866 if(!isWasmInitialized) {
44867 throw new Error("initializeWasm() must be awaited first!");
44869 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
44870 return nativeResponseValue;
44872 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
44874 export function NodeAlias_read(ser: number): bigint {
44875 if(!isWasmInitialized) {
44876 throw new Error("initializeWasm() must be awaited first!");
44878 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
44879 return nativeResponseValue;
44881 // void NodeInfo_free(struct LDKNodeInfo this_obj);
44883 export function NodeInfo_free(this_obj: bigint): void {
44884 if(!isWasmInitialized) {
44885 throw new Error("initializeWasm() must be awaited first!");
44887 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
44888 // debug statements here
44890 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
44892 export function NodeInfo_get_channels(this_ptr: bigint): number {
44893 if(!isWasmInitialized) {
44894 throw new Error("initializeWasm() must be awaited first!");
44896 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
44897 return nativeResponseValue;
44899 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
44901 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
44902 if(!isWasmInitialized) {
44903 throw new Error("initializeWasm() must be awaited first!");
44905 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
44906 // debug statements here
44908 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
44910 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
44911 if(!isWasmInitialized) {
44912 throw new Error("initializeWasm() must be awaited first!");
44914 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
44915 return nativeResponseValue;
44917 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
44919 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
44920 if(!isWasmInitialized) {
44921 throw new Error("initializeWasm() must be awaited first!");
44923 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
44924 // debug statements here
44926 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
44928 export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
44929 if(!isWasmInitialized) {
44930 throw new Error("initializeWasm() must be awaited first!");
44932 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
44933 return nativeResponseValue;
44935 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
44937 export function NodeInfo_clone_ptr(arg: bigint): bigint {
44938 if(!isWasmInitialized) {
44939 throw new Error("initializeWasm() must be awaited first!");
44941 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
44942 return nativeResponseValue;
44944 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
44946 export function NodeInfo_clone(orig: bigint): bigint {
44947 if(!isWasmInitialized) {
44948 throw new Error("initializeWasm() must be awaited first!");
44950 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
44951 return nativeResponseValue;
44953 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
44955 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
44956 if(!isWasmInitialized) {
44957 throw new Error("initializeWasm() must be awaited first!");
44959 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
44960 return nativeResponseValue;
44962 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
44964 export function NodeInfo_write(obj: bigint): number {
44965 if(!isWasmInitialized) {
44966 throw new Error("initializeWasm() must be awaited first!");
44968 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
44969 return nativeResponseValue;
44971 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
44973 export function NodeInfo_read(ser: number): bigint {
44974 if(!isWasmInitialized) {
44975 throw new Error("initializeWasm() must be awaited first!");
44977 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
44978 return nativeResponseValue;
44980 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
44982 export function NetworkGraph_write(obj: bigint): number {
44983 if(!isWasmInitialized) {
44984 throw new Error("initializeWasm() must be awaited first!");
44986 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
44987 return nativeResponseValue;
44989 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
44991 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
44992 if(!isWasmInitialized) {
44993 throw new Error("initializeWasm() must be awaited first!");
44995 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
44996 return nativeResponseValue;
44998 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
45000 export function NetworkGraph_new(network: Network, logger: bigint): bigint {
45001 if(!isWasmInitialized) {
45002 throw new Error("initializeWasm() must be awaited first!");
45004 const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
45005 return nativeResponseValue;
45007 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
45009 export function NetworkGraph_read_only(this_arg: bigint): bigint {
45010 if(!isWasmInitialized) {
45011 throw new Error("initializeWasm() must be awaited first!");
45013 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
45014 return nativeResponseValue;
45016 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
45018 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
45019 if(!isWasmInitialized) {
45020 throw new Error("initializeWasm() must be awaited first!");
45022 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
45023 return nativeResponseValue;
45025 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
45027 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
45028 if(!isWasmInitialized) {
45029 throw new Error("initializeWasm() must be awaited first!");
45031 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
45032 // debug statements here
45034 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
45036 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
45037 if(!isWasmInitialized) {
45038 throw new Error("initializeWasm() must be awaited first!");
45040 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
45041 return nativeResponseValue;
45043 // 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);
45045 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
45046 if(!isWasmInitialized) {
45047 throw new Error("initializeWasm() must be awaited first!");
45049 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
45050 return nativeResponseValue;
45052 // 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);
45054 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
45055 if(!isWasmInitialized) {
45056 throw new Error("initializeWasm() must be awaited first!");
45058 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
45059 return nativeResponseValue;
45061 // 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);
45063 export function NetworkGraph_update_channel_from_announcement_no_lookup(this_arg: bigint, msg: bigint): bigint {
45064 if(!isWasmInitialized) {
45065 throw new Error("initializeWasm() must be awaited first!");
45067 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement_no_lookup(this_arg, msg);
45068 return nativeResponseValue;
45070 // 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);
45072 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
45073 if(!isWasmInitialized) {
45074 throw new Error("initializeWasm() must be awaited first!");
45076 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
45077 return nativeResponseValue;
45079 // 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);
45081 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 {
45082 if(!isWasmInitialized) {
45083 throw new Error("initializeWasm() must be awaited first!");
45085 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
45086 return nativeResponseValue;
45088 // void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
45090 export function NetworkGraph_channel_failed_permanent(this_arg: bigint, short_channel_id: bigint): void {
45091 if(!isWasmInitialized) {
45092 throw new Error("initializeWasm() must be awaited first!");
45094 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
45095 // debug statements here
45097 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
45099 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
45100 if(!isWasmInitialized) {
45101 throw new Error("initializeWasm() must be awaited first!");
45103 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
45104 // debug statements here
45106 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
45108 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
45109 if(!isWasmInitialized) {
45110 throw new Error("initializeWasm() must be awaited first!");
45112 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
45113 // debug statements here
45115 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
45117 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
45118 if(!isWasmInitialized) {
45119 throw new Error("initializeWasm() must be awaited first!");
45121 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
45122 return nativeResponseValue;
45124 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
45126 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
45127 if(!isWasmInitialized) {
45128 throw new Error("initializeWasm() must be awaited first!");
45130 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
45131 return nativeResponseValue;
45133 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
45135 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
45136 if(!isWasmInitialized) {
45137 throw new Error("initializeWasm() must be awaited first!");
45139 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
45140 return nativeResponseValue;
45142 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
45144 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
45145 if(!isWasmInitialized) {
45146 throw new Error("initializeWasm() must be awaited first!");
45148 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
45149 return nativeResponseValue;
45151 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
45153 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
45154 if(!isWasmInitialized) {
45155 throw new Error("initializeWasm() must be awaited first!");
45157 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
45158 return nativeResponseValue;
45160 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
45162 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
45163 if(!isWasmInitialized) {
45164 throw new Error("initializeWasm() must be awaited first!");
45166 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
45167 return nativeResponseValue;
45169 // MUST_USE_RES struct LDKCOption_CVec_SocketAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
45171 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
45172 if(!isWasmInitialized) {
45173 throw new Error("initializeWasm() must be awaited first!");
45175 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
45176 return nativeResponseValue;
45178 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
45180 export function DefaultRouter_free(this_obj: bigint): void {
45181 if(!isWasmInitialized) {
45182 throw new Error("initializeWasm() must be awaited first!");
45184 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
45185 // debug statements here
45187 // 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);
45189 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint, score_params: bigint): bigint {
45190 if(!isWasmInitialized) {
45191 throw new Error("initializeWasm() must be awaited first!");
45193 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer, score_params);
45194 return nativeResponseValue;
45196 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
45198 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
45199 if(!isWasmInitialized) {
45200 throw new Error("initializeWasm() must be awaited first!");
45202 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
45203 return nativeResponseValue;
45205 // void Router_free(struct LDKRouter this_ptr);
45207 export function Router_free(this_ptr: bigint): void {
45208 if(!isWasmInitialized) {
45209 throw new Error("initializeWasm() must be awaited first!");
45211 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
45212 // debug statements here
45214 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
45216 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
45217 if(!isWasmInitialized) {
45218 throw new Error("initializeWasm() must be awaited first!");
45220 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
45221 // debug statements here
45223 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScoreLookUp scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
45225 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
45226 if(!isWasmInitialized) {
45227 throw new Error("initializeWasm() must be awaited first!");
45229 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
45230 return nativeResponseValue;
45232 // struct LDKScoreLookUp ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
45234 export function ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg: bigint): bigint {
45235 if(!isWasmInitialized) {
45236 throw new Error("initializeWasm() must be awaited first!");
45238 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg);
45239 return nativeResponseValue;
45241 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
45243 export function InFlightHtlcs_free(this_obj: bigint): void {
45244 if(!isWasmInitialized) {
45245 throw new Error("initializeWasm() must be awaited first!");
45247 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
45248 // debug statements here
45250 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
45252 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
45253 if(!isWasmInitialized) {
45254 throw new Error("initializeWasm() must be awaited first!");
45256 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
45257 return nativeResponseValue;
45259 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
45261 export function InFlightHtlcs_clone(orig: bigint): bigint {
45262 if(!isWasmInitialized) {
45263 throw new Error("initializeWasm() must be awaited first!");
45265 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
45266 return nativeResponseValue;
45268 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
45270 export function InFlightHtlcs_new(): bigint {
45271 if(!isWasmInitialized) {
45272 throw new Error("initializeWasm() must be awaited first!");
45274 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
45275 return nativeResponseValue;
45277 // void InFlightHtlcs_process_path(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, struct LDKPublicKey payer_node_id);
45279 export function InFlightHtlcs_process_path(this_arg: bigint, path: bigint, payer_node_id: number): void {
45280 if(!isWasmInitialized) {
45281 throw new Error("initializeWasm() must be awaited first!");
45283 const nativeResponseValue = wasm.TS_InFlightHtlcs_process_path(this_arg, path, payer_node_id);
45284 // debug statements here
45286 // 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);
45288 export function InFlightHtlcs_add_inflight_htlc(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint, used_msat: bigint): void {
45289 if(!isWasmInitialized) {
45290 throw new Error("initializeWasm() must be awaited first!");
45292 const nativeResponseValue = wasm.TS_InFlightHtlcs_add_inflight_htlc(this_arg, source, target, channel_scid, used_msat);
45293 // debug statements here
45295 // 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);
45297 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
45298 if(!isWasmInitialized) {
45299 throw new Error("initializeWasm() must be awaited first!");
45301 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
45302 return nativeResponseValue;
45304 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
45306 export function InFlightHtlcs_write(obj: bigint): number {
45307 if(!isWasmInitialized) {
45308 throw new Error("initializeWasm() must be awaited first!");
45310 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
45311 return nativeResponseValue;
45313 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
45315 export function InFlightHtlcs_read(ser: number): bigint {
45316 if(!isWasmInitialized) {
45317 throw new Error("initializeWasm() must be awaited first!");
45319 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
45320 return nativeResponseValue;
45322 // void RouteHop_free(struct LDKRouteHop this_obj);
45324 export function RouteHop_free(this_obj: bigint): void {
45325 if(!isWasmInitialized) {
45326 throw new Error("initializeWasm() must be awaited first!");
45328 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
45329 // debug statements here
45331 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45333 export function RouteHop_get_pubkey(this_ptr: bigint): number {
45334 if(!isWasmInitialized) {
45335 throw new Error("initializeWasm() must be awaited first!");
45337 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
45338 return nativeResponseValue;
45340 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
45342 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
45343 if(!isWasmInitialized) {
45344 throw new Error("initializeWasm() must be awaited first!");
45346 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
45347 // debug statements here
45349 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45351 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
45352 if(!isWasmInitialized) {
45353 throw new Error("initializeWasm() must be awaited first!");
45355 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
45356 return nativeResponseValue;
45358 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
45360 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
45361 if(!isWasmInitialized) {
45362 throw new Error("initializeWasm() must be awaited first!");
45364 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
45365 // debug statements here
45367 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45369 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
45370 if(!isWasmInitialized) {
45371 throw new Error("initializeWasm() must be awaited first!");
45373 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
45374 return nativeResponseValue;
45376 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
45378 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
45379 if(!isWasmInitialized) {
45380 throw new Error("initializeWasm() must be awaited first!");
45382 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
45383 // debug statements here
45385 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45387 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
45388 if(!isWasmInitialized) {
45389 throw new Error("initializeWasm() must be awaited first!");
45391 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
45392 return nativeResponseValue;
45394 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
45396 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
45397 if(!isWasmInitialized) {
45398 throw new Error("initializeWasm() must be awaited first!");
45400 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
45401 // debug statements here
45403 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45405 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
45406 if(!isWasmInitialized) {
45407 throw new Error("initializeWasm() must be awaited first!");
45409 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
45410 return nativeResponseValue;
45412 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
45414 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
45415 if(!isWasmInitialized) {
45416 throw new Error("initializeWasm() must be awaited first!");
45418 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
45419 // debug statements here
45421 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45423 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
45424 if(!isWasmInitialized) {
45425 throw new Error("initializeWasm() must be awaited first!");
45427 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
45428 return nativeResponseValue;
45430 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
45432 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
45433 if(!isWasmInitialized) {
45434 throw new Error("initializeWasm() must be awaited first!");
45436 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
45437 // debug statements here
45439 // bool RouteHop_get_maybe_announced_channel(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45441 export function RouteHop_get_maybe_announced_channel(this_ptr: bigint): boolean {
45442 if(!isWasmInitialized) {
45443 throw new Error("initializeWasm() must be awaited first!");
45445 const nativeResponseValue = wasm.TS_RouteHop_get_maybe_announced_channel(this_ptr);
45446 return nativeResponseValue;
45448 // void RouteHop_set_maybe_announced_channel(struct LDKRouteHop *NONNULL_PTR this_ptr, bool val);
45450 export function RouteHop_set_maybe_announced_channel(this_ptr: bigint, val: boolean): void {
45451 if(!isWasmInitialized) {
45452 throw new Error("initializeWasm() must be awaited first!");
45454 const nativeResponseValue = wasm.TS_RouteHop_set_maybe_announced_channel(this_ptr, val);
45455 // debug statements here
45457 // 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, bool maybe_announced_channel_arg);
45459 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, maybe_announced_channel_arg: boolean): bigint {
45460 if(!isWasmInitialized) {
45461 throw new Error("initializeWasm() must be awaited first!");
45463 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, maybe_announced_channel_arg);
45464 return nativeResponseValue;
45466 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
45468 export function RouteHop_clone_ptr(arg: bigint): bigint {
45469 if(!isWasmInitialized) {
45470 throw new Error("initializeWasm() must be awaited first!");
45472 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
45473 return nativeResponseValue;
45475 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
45477 export function RouteHop_clone(orig: bigint): bigint {
45478 if(!isWasmInitialized) {
45479 throw new Error("initializeWasm() must be awaited first!");
45481 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
45482 return nativeResponseValue;
45484 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
45486 export function RouteHop_hash(o: bigint): bigint {
45487 if(!isWasmInitialized) {
45488 throw new Error("initializeWasm() must be awaited first!");
45490 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
45491 return nativeResponseValue;
45493 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
45495 export function RouteHop_eq(a: bigint, b: bigint): boolean {
45496 if(!isWasmInitialized) {
45497 throw new Error("initializeWasm() must be awaited first!");
45499 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
45500 return nativeResponseValue;
45502 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
45504 export function RouteHop_write(obj: bigint): number {
45505 if(!isWasmInitialized) {
45506 throw new Error("initializeWasm() must be awaited first!");
45508 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
45509 return nativeResponseValue;
45511 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
45513 export function RouteHop_read(ser: number): bigint {
45514 if(!isWasmInitialized) {
45515 throw new Error("initializeWasm() must be awaited first!");
45517 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
45518 return nativeResponseValue;
45520 // void BlindedTail_free(struct LDKBlindedTail this_obj);
45522 export function BlindedTail_free(this_obj: bigint): void {
45523 if(!isWasmInitialized) {
45524 throw new Error("initializeWasm() must be awaited first!");
45526 const nativeResponseValue = wasm.TS_BlindedTail_free(this_obj);
45527 // debug statements here
45529 // struct LDKCVec_BlindedHopZ BlindedTail_get_hops(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
45531 export function BlindedTail_get_hops(this_ptr: bigint): number {
45532 if(!isWasmInitialized) {
45533 throw new Error("initializeWasm() must be awaited first!");
45535 const nativeResponseValue = wasm.TS_BlindedTail_get_hops(this_ptr);
45536 return nativeResponseValue;
45538 // void BlindedTail_set_hops(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
45540 export function BlindedTail_set_hops(this_ptr: bigint, val: number): void {
45541 if(!isWasmInitialized) {
45542 throw new Error("initializeWasm() must be awaited first!");
45544 const nativeResponseValue = wasm.TS_BlindedTail_set_hops(this_ptr, val);
45545 // debug statements here
45547 // struct LDKPublicKey BlindedTail_get_blinding_point(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
45549 export function BlindedTail_get_blinding_point(this_ptr: bigint): number {
45550 if(!isWasmInitialized) {
45551 throw new Error("initializeWasm() must be awaited first!");
45553 const nativeResponseValue = wasm.TS_BlindedTail_get_blinding_point(this_ptr);
45554 return nativeResponseValue;
45556 // void BlindedTail_set_blinding_point(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKPublicKey val);
45558 export function BlindedTail_set_blinding_point(this_ptr: bigint, val: number): void {
45559 if(!isWasmInitialized) {
45560 throw new Error("initializeWasm() must be awaited first!");
45562 const nativeResponseValue = wasm.TS_BlindedTail_set_blinding_point(this_ptr, val);
45563 // debug statements here
45565 // uint32_t BlindedTail_get_excess_final_cltv_expiry_delta(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
45567 export function BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr: bigint): number {
45568 if(!isWasmInitialized) {
45569 throw new Error("initializeWasm() must be awaited first!");
45571 const nativeResponseValue = wasm.TS_BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr);
45572 return nativeResponseValue;
45574 // void BlindedTail_set_excess_final_cltv_expiry_delta(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint32_t val);
45576 export function BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
45577 if(!isWasmInitialized) {
45578 throw new Error("initializeWasm() must be awaited first!");
45580 const nativeResponseValue = wasm.TS_BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr, val);
45581 // debug statements here
45583 // uint64_t BlindedTail_get_final_value_msat(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
45585 export function BlindedTail_get_final_value_msat(this_ptr: bigint): bigint {
45586 if(!isWasmInitialized) {
45587 throw new Error("initializeWasm() must be awaited first!");
45589 const nativeResponseValue = wasm.TS_BlindedTail_get_final_value_msat(this_ptr);
45590 return nativeResponseValue;
45592 // void BlindedTail_set_final_value_msat(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint64_t val);
45594 export function BlindedTail_set_final_value_msat(this_ptr: bigint, val: bigint): void {
45595 if(!isWasmInitialized) {
45596 throw new Error("initializeWasm() must be awaited first!");
45598 const nativeResponseValue = wasm.TS_BlindedTail_set_final_value_msat(this_ptr, val);
45599 // debug statements here
45601 // 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);
45603 export function BlindedTail_new(hops_arg: number, blinding_point_arg: number, excess_final_cltv_expiry_delta_arg: number, final_value_msat_arg: bigint): bigint {
45604 if(!isWasmInitialized) {
45605 throw new Error("initializeWasm() must be awaited first!");
45607 const nativeResponseValue = wasm.TS_BlindedTail_new(hops_arg, blinding_point_arg, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
45608 return nativeResponseValue;
45610 // uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg);
45612 export function BlindedTail_clone_ptr(arg: bigint): bigint {
45613 if(!isWasmInitialized) {
45614 throw new Error("initializeWasm() must be awaited first!");
45616 const nativeResponseValue = wasm.TS_BlindedTail_clone_ptr(arg);
45617 return nativeResponseValue;
45619 // struct LDKBlindedTail BlindedTail_clone(const struct LDKBlindedTail *NONNULL_PTR orig);
45621 export function BlindedTail_clone(orig: bigint): bigint {
45622 if(!isWasmInitialized) {
45623 throw new Error("initializeWasm() must be awaited first!");
45625 const nativeResponseValue = wasm.TS_BlindedTail_clone(orig);
45626 return nativeResponseValue;
45628 // uint64_t BlindedTail_hash(const struct LDKBlindedTail *NONNULL_PTR o);
45630 export function BlindedTail_hash(o: bigint): bigint {
45631 if(!isWasmInitialized) {
45632 throw new Error("initializeWasm() must be awaited first!");
45634 const nativeResponseValue = wasm.TS_BlindedTail_hash(o);
45635 return nativeResponseValue;
45637 // bool BlindedTail_eq(const struct LDKBlindedTail *NONNULL_PTR a, const struct LDKBlindedTail *NONNULL_PTR b);
45639 export function BlindedTail_eq(a: bigint, b: bigint): boolean {
45640 if(!isWasmInitialized) {
45641 throw new Error("initializeWasm() must be awaited first!");
45643 const nativeResponseValue = wasm.TS_BlindedTail_eq(a, b);
45644 return nativeResponseValue;
45646 // struct LDKCVec_u8Z BlindedTail_write(const struct LDKBlindedTail *NONNULL_PTR obj);
45648 export function BlindedTail_write(obj: bigint): number {
45649 if(!isWasmInitialized) {
45650 throw new Error("initializeWasm() must be awaited first!");
45652 const nativeResponseValue = wasm.TS_BlindedTail_write(obj);
45653 return nativeResponseValue;
45655 // struct LDKCResult_BlindedTailDecodeErrorZ BlindedTail_read(struct LDKu8slice ser);
45657 export function BlindedTail_read(ser: number): bigint {
45658 if(!isWasmInitialized) {
45659 throw new Error("initializeWasm() must be awaited first!");
45661 const nativeResponseValue = wasm.TS_BlindedTail_read(ser);
45662 return nativeResponseValue;
45664 // void Path_free(struct LDKPath this_obj);
45666 export function Path_free(this_obj: bigint): void {
45667 if(!isWasmInitialized) {
45668 throw new Error("initializeWasm() must be awaited first!");
45670 const nativeResponseValue = wasm.TS_Path_free(this_obj);
45671 // debug statements here
45673 // struct LDKCVec_RouteHopZ Path_get_hops(const struct LDKPath *NONNULL_PTR this_ptr);
45675 export function Path_get_hops(this_ptr: bigint): number {
45676 if(!isWasmInitialized) {
45677 throw new Error("initializeWasm() must be awaited first!");
45679 const nativeResponseValue = wasm.TS_Path_get_hops(this_ptr);
45680 return nativeResponseValue;
45682 // void Path_set_hops(struct LDKPath *NONNULL_PTR this_ptr, struct LDKCVec_RouteHopZ val);
45684 export function Path_set_hops(this_ptr: bigint, val: number): void {
45685 if(!isWasmInitialized) {
45686 throw new Error("initializeWasm() must be awaited first!");
45688 const nativeResponseValue = wasm.TS_Path_set_hops(this_ptr, val);
45689 // debug statements here
45691 // struct LDKBlindedTail Path_get_blinded_tail(const struct LDKPath *NONNULL_PTR this_ptr);
45693 export function Path_get_blinded_tail(this_ptr: bigint): bigint {
45694 if(!isWasmInitialized) {
45695 throw new Error("initializeWasm() must be awaited first!");
45697 const nativeResponseValue = wasm.TS_Path_get_blinded_tail(this_ptr);
45698 return nativeResponseValue;
45700 // void Path_set_blinded_tail(struct LDKPath *NONNULL_PTR this_ptr, struct LDKBlindedTail val);
45702 export function Path_set_blinded_tail(this_ptr: bigint, val: bigint): void {
45703 if(!isWasmInitialized) {
45704 throw new Error("initializeWasm() must be awaited first!");
45706 const nativeResponseValue = wasm.TS_Path_set_blinded_tail(this_ptr, val);
45707 // debug statements here
45709 // MUST_USE_RES struct LDKPath Path_new(struct LDKCVec_RouteHopZ hops_arg, struct LDKBlindedTail blinded_tail_arg);
45711 export function Path_new(hops_arg: number, blinded_tail_arg: bigint): bigint {
45712 if(!isWasmInitialized) {
45713 throw new Error("initializeWasm() must be awaited first!");
45715 const nativeResponseValue = wasm.TS_Path_new(hops_arg, blinded_tail_arg);
45716 return nativeResponseValue;
45718 // uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg);
45720 export function Path_clone_ptr(arg: bigint): bigint {
45721 if(!isWasmInitialized) {
45722 throw new Error("initializeWasm() must be awaited first!");
45724 const nativeResponseValue = wasm.TS_Path_clone_ptr(arg);
45725 return nativeResponseValue;
45727 // struct LDKPath Path_clone(const struct LDKPath *NONNULL_PTR orig);
45729 export function Path_clone(orig: bigint): bigint {
45730 if(!isWasmInitialized) {
45731 throw new Error("initializeWasm() must be awaited first!");
45733 const nativeResponseValue = wasm.TS_Path_clone(orig);
45734 return nativeResponseValue;
45736 // uint64_t Path_hash(const struct LDKPath *NONNULL_PTR o);
45738 export function Path_hash(o: bigint): bigint {
45739 if(!isWasmInitialized) {
45740 throw new Error("initializeWasm() must be awaited first!");
45742 const nativeResponseValue = wasm.TS_Path_hash(o);
45743 return nativeResponseValue;
45745 // bool Path_eq(const struct LDKPath *NONNULL_PTR a, const struct LDKPath *NONNULL_PTR b);
45747 export function Path_eq(a: bigint, b: bigint): boolean {
45748 if(!isWasmInitialized) {
45749 throw new Error("initializeWasm() must be awaited first!");
45751 const nativeResponseValue = wasm.TS_Path_eq(a, b);
45752 return nativeResponseValue;
45754 // MUST_USE_RES uint64_t Path_fee_msat(const struct LDKPath *NONNULL_PTR this_arg);
45756 export function Path_fee_msat(this_arg: bigint): bigint {
45757 if(!isWasmInitialized) {
45758 throw new Error("initializeWasm() must be awaited first!");
45760 const nativeResponseValue = wasm.TS_Path_fee_msat(this_arg);
45761 return nativeResponseValue;
45763 // MUST_USE_RES uint64_t Path_final_value_msat(const struct LDKPath *NONNULL_PTR this_arg);
45765 export function Path_final_value_msat(this_arg: bigint): bigint {
45766 if(!isWasmInitialized) {
45767 throw new Error("initializeWasm() must be awaited first!");
45769 const nativeResponseValue = wasm.TS_Path_final_value_msat(this_arg);
45770 return nativeResponseValue;
45772 // MUST_USE_RES struct LDKCOption_u32Z Path_final_cltv_expiry_delta(const struct LDKPath *NONNULL_PTR this_arg);
45774 export function Path_final_cltv_expiry_delta(this_arg: bigint): bigint {
45775 if(!isWasmInitialized) {
45776 throw new Error("initializeWasm() must be awaited first!");
45778 const nativeResponseValue = wasm.TS_Path_final_cltv_expiry_delta(this_arg);
45779 return nativeResponseValue;
45781 // void Route_free(struct LDKRoute this_obj);
45783 export function Route_free(this_obj: bigint): void {
45784 if(!isWasmInitialized) {
45785 throw new Error("initializeWasm() must be awaited first!");
45787 const nativeResponseValue = wasm.TS_Route_free(this_obj);
45788 // debug statements here
45790 // struct LDKCVec_PathZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
45792 export function Route_get_paths(this_ptr: bigint): number {
45793 if(!isWasmInitialized) {
45794 throw new Error("initializeWasm() must be awaited first!");
45796 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
45797 return nativeResponseValue;
45799 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_PathZ val);
45801 export function Route_set_paths(this_ptr: bigint, val: number): void {
45802 if(!isWasmInitialized) {
45803 throw new Error("initializeWasm() must be awaited first!");
45805 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
45806 // debug statements here
45808 // struct LDKRouteParameters Route_get_route_params(const struct LDKRoute *NONNULL_PTR this_ptr);
45810 export function Route_get_route_params(this_ptr: bigint): bigint {
45811 if(!isWasmInitialized) {
45812 throw new Error("initializeWasm() must be awaited first!");
45814 const nativeResponseValue = wasm.TS_Route_get_route_params(this_ptr);
45815 return nativeResponseValue;
45817 // void Route_set_route_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKRouteParameters val);
45819 export function Route_set_route_params(this_ptr: bigint, val: bigint): void {
45820 if(!isWasmInitialized) {
45821 throw new Error("initializeWasm() must be awaited first!");
45823 const nativeResponseValue = wasm.TS_Route_set_route_params(this_ptr, val);
45824 // debug statements here
45826 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKRouteParameters route_params_arg);
45828 export function Route_new(paths_arg: number, route_params_arg: bigint): bigint {
45829 if(!isWasmInitialized) {
45830 throw new Error("initializeWasm() must be awaited first!");
45832 const nativeResponseValue = wasm.TS_Route_new(paths_arg, route_params_arg);
45833 return nativeResponseValue;
45835 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
45837 export function Route_clone_ptr(arg: bigint): bigint {
45838 if(!isWasmInitialized) {
45839 throw new Error("initializeWasm() must be awaited first!");
45841 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
45842 return nativeResponseValue;
45844 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
45846 export function Route_clone(orig: bigint): bigint {
45847 if(!isWasmInitialized) {
45848 throw new Error("initializeWasm() must be awaited first!");
45850 const nativeResponseValue = wasm.TS_Route_clone(orig);
45851 return nativeResponseValue;
45853 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
45855 export function Route_hash(o: bigint): bigint {
45856 if(!isWasmInitialized) {
45857 throw new Error("initializeWasm() must be awaited first!");
45859 const nativeResponseValue = wasm.TS_Route_hash(o);
45860 return nativeResponseValue;
45862 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
45864 export function Route_eq(a: bigint, b: bigint): boolean {
45865 if(!isWasmInitialized) {
45866 throw new Error("initializeWasm() must be awaited first!");
45868 const nativeResponseValue = wasm.TS_Route_eq(a, b);
45869 return nativeResponseValue;
45871 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
45873 export function Route_get_total_fees(this_arg: bigint): bigint {
45874 if(!isWasmInitialized) {
45875 throw new Error("initializeWasm() must be awaited first!");
45877 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
45878 return nativeResponseValue;
45880 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
45882 export function Route_get_total_amount(this_arg: bigint): bigint {
45883 if(!isWasmInitialized) {
45884 throw new Error("initializeWasm() must be awaited first!");
45886 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
45887 return nativeResponseValue;
45889 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
45891 export function Route_write(obj: bigint): number {
45892 if(!isWasmInitialized) {
45893 throw new Error("initializeWasm() must be awaited first!");
45895 const nativeResponseValue = wasm.TS_Route_write(obj);
45896 return nativeResponseValue;
45898 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
45900 export function Route_read(ser: number): bigint {
45901 if(!isWasmInitialized) {
45902 throw new Error("initializeWasm() must be awaited first!");
45904 const nativeResponseValue = wasm.TS_Route_read(ser);
45905 return nativeResponseValue;
45907 // void RouteParameters_free(struct LDKRouteParameters this_obj);
45909 export function RouteParameters_free(this_obj: bigint): void {
45910 if(!isWasmInitialized) {
45911 throw new Error("initializeWasm() must be awaited first!");
45913 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
45914 // debug statements here
45916 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
45918 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
45919 if(!isWasmInitialized) {
45920 throw new Error("initializeWasm() must be awaited first!");
45922 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
45923 return nativeResponseValue;
45925 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
45927 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
45928 if(!isWasmInitialized) {
45929 throw new Error("initializeWasm() must be awaited first!");
45931 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
45932 // debug statements here
45934 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
45936 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
45937 if(!isWasmInitialized) {
45938 throw new Error("initializeWasm() must be awaited first!");
45940 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
45941 return nativeResponseValue;
45943 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
45945 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
45946 if(!isWasmInitialized) {
45947 throw new Error("initializeWasm() must be awaited first!");
45949 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
45950 // debug statements here
45952 // struct LDKCOption_u64Z RouteParameters_get_max_total_routing_fee_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
45954 export function RouteParameters_get_max_total_routing_fee_msat(this_ptr: bigint): bigint {
45955 if(!isWasmInitialized) {
45956 throw new Error("initializeWasm() must be awaited first!");
45958 const nativeResponseValue = wasm.TS_RouteParameters_get_max_total_routing_fee_msat(this_ptr);
45959 return nativeResponseValue;
45961 // void RouteParameters_set_max_total_routing_fee_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
45963 export function RouteParameters_set_max_total_routing_fee_msat(this_ptr: bigint, val: bigint): void {
45964 if(!isWasmInitialized) {
45965 throw new Error("initializeWasm() must be awaited first!");
45967 const nativeResponseValue = wasm.TS_RouteParameters_set_max_total_routing_fee_msat(this_ptr, val);
45968 // debug statements here
45970 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg, struct LDKCOption_u64Z max_total_routing_fee_msat_arg);
45972 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, max_total_routing_fee_msat_arg: bigint): bigint {
45973 if(!isWasmInitialized) {
45974 throw new Error("initializeWasm() must be awaited first!");
45976 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, max_total_routing_fee_msat_arg);
45977 return nativeResponseValue;
45979 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
45981 export function RouteParameters_clone_ptr(arg: bigint): bigint {
45982 if(!isWasmInitialized) {
45983 throw new Error("initializeWasm() must be awaited first!");
45985 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
45986 return nativeResponseValue;
45988 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
45990 export function RouteParameters_clone(orig: bigint): bigint {
45991 if(!isWasmInitialized) {
45992 throw new Error("initializeWasm() must be awaited first!");
45994 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
45995 return nativeResponseValue;
45997 // uint64_t RouteParameters_hash(const struct LDKRouteParameters *NONNULL_PTR o);
45999 export function RouteParameters_hash(o: bigint): bigint {
46000 if(!isWasmInitialized) {
46001 throw new Error("initializeWasm() must be awaited first!");
46003 const nativeResponseValue = wasm.TS_RouteParameters_hash(o);
46004 return nativeResponseValue;
46006 // bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
46008 export function RouteParameters_eq(a: bigint, b: bigint): boolean {
46009 if(!isWasmInitialized) {
46010 throw new Error("initializeWasm() must be awaited first!");
46012 const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
46013 return nativeResponseValue;
46015 // MUST_USE_RES struct LDKRouteParameters RouteParameters_from_payment_params_and_value(struct LDKPaymentParameters payment_params, uint64_t final_value_msat);
46017 export function RouteParameters_from_payment_params_and_value(payment_params: bigint, final_value_msat: bigint): bigint {
46018 if(!isWasmInitialized) {
46019 throw new Error("initializeWasm() must be awaited first!");
46021 const nativeResponseValue = wasm.TS_RouteParameters_from_payment_params_and_value(payment_params, final_value_msat);
46022 return nativeResponseValue;
46024 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
46026 export function RouteParameters_write(obj: bigint): number {
46027 if(!isWasmInitialized) {
46028 throw new Error("initializeWasm() must be awaited first!");
46030 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
46031 return nativeResponseValue;
46033 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
46035 export function RouteParameters_read(ser: number): bigint {
46036 if(!isWasmInitialized) {
46037 throw new Error("initializeWasm() must be awaited first!");
46039 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
46040 return nativeResponseValue;
46042 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
46044 export function PaymentParameters_free(this_obj: bigint): void {
46045 if(!isWasmInitialized) {
46046 throw new Error("initializeWasm() must be awaited first!");
46048 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
46049 // debug statements here
46051 // struct LDKPayee PaymentParameters_get_payee(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46053 export function PaymentParameters_get_payee(this_ptr: bigint): bigint {
46054 if(!isWasmInitialized) {
46055 throw new Error("initializeWasm() must be awaited first!");
46057 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee(this_ptr);
46058 return nativeResponseValue;
46060 // void PaymentParameters_set_payee(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
46062 export function PaymentParameters_set_payee(this_ptr: bigint, val: bigint): void {
46063 if(!isWasmInitialized) {
46064 throw new Error("initializeWasm() must be awaited first!");
46066 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee(this_ptr, val);
46067 // debug statements here
46069 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46071 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
46072 if(!isWasmInitialized) {
46073 throw new Error("initializeWasm() must be awaited first!");
46075 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
46076 return nativeResponseValue;
46078 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
46080 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
46081 if(!isWasmInitialized) {
46082 throw new Error("initializeWasm() must be awaited first!");
46084 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
46085 // debug statements here
46087 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46089 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
46090 if(!isWasmInitialized) {
46091 throw new Error("initializeWasm() must be awaited first!");
46093 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
46094 return nativeResponseValue;
46096 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
46098 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
46099 if(!isWasmInitialized) {
46100 throw new Error("initializeWasm() must be awaited first!");
46102 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
46103 // debug statements here
46105 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46107 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
46108 if(!isWasmInitialized) {
46109 throw new Error("initializeWasm() must be awaited first!");
46111 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
46112 return nativeResponseValue;
46114 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
46116 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
46117 if(!isWasmInitialized) {
46118 throw new Error("initializeWasm() must be awaited first!");
46120 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
46121 // debug statements here
46123 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46125 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
46126 if(!isWasmInitialized) {
46127 throw new Error("initializeWasm() must be awaited first!");
46129 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
46130 return nativeResponseValue;
46132 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
46134 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
46135 if(!isWasmInitialized) {
46136 throw new Error("initializeWasm() must be awaited first!");
46138 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
46139 // debug statements here
46141 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46143 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
46144 if(!isWasmInitialized) {
46145 throw new Error("initializeWasm() must be awaited first!");
46147 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
46148 return nativeResponseValue;
46150 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
46152 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
46153 if(!isWasmInitialized) {
46154 throw new Error("initializeWasm() must be awaited first!");
46156 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
46157 // debug statements here
46159 // 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);
46161 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 {
46162 if(!isWasmInitialized) {
46163 throw new Error("initializeWasm() must be awaited first!");
46165 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);
46166 return nativeResponseValue;
46168 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
46170 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
46171 if(!isWasmInitialized) {
46172 throw new Error("initializeWasm() must be awaited first!");
46174 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
46175 return nativeResponseValue;
46177 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
46179 export function PaymentParameters_clone(orig: bigint): bigint {
46180 if(!isWasmInitialized) {
46181 throw new Error("initializeWasm() must be awaited first!");
46183 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
46184 return nativeResponseValue;
46186 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
46188 export function PaymentParameters_hash(o: bigint): bigint {
46189 if(!isWasmInitialized) {
46190 throw new Error("initializeWasm() must be awaited first!");
46192 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
46193 return nativeResponseValue;
46195 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
46197 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
46198 if(!isWasmInitialized) {
46199 throw new Error("initializeWasm() must be awaited first!");
46201 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
46202 return nativeResponseValue;
46204 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
46206 export function PaymentParameters_write(obj: bigint): number {
46207 if(!isWasmInitialized) {
46208 throw new Error("initializeWasm() must be awaited first!");
46210 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
46211 return nativeResponseValue;
46213 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
46215 export function PaymentParameters_read(ser: number, arg: number): bigint {
46216 if(!isWasmInitialized) {
46217 throw new Error("initializeWasm() must be awaited first!");
46219 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
46220 return nativeResponseValue;
46222 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
46224 export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
46225 if(!isWasmInitialized) {
46226 throw new Error("initializeWasm() must be awaited first!");
46228 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
46229 return nativeResponseValue;
46231 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta, bool allow_mpp);
46233 export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number, allow_mpp: boolean): bigint {
46234 if(!isWasmInitialized) {
46235 throw new Error("initializeWasm() must be awaited first!");
46237 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta, allow_mpp);
46238 return nativeResponseValue;
46240 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_bolt12_invoice(const struct LDKBolt12Invoice *NONNULL_PTR invoice);
46242 export function PaymentParameters_from_bolt12_invoice(invoice: bigint): bigint {
46243 if(!isWasmInitialized) {
46244 throw new Error("initializeWasm() must be awaited first!");
46246 const nativeResponseValue = wasm.TS_PaymentParameters_from_bolt12_invoice(invoice);
46247 return nativeResponseValue;
46249 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_route_hints);
46251 export function PaymentParameters_blinded(blinded_route_hints: number): bigint {
46252 if(!isWasmInitialized) {
46253 throw new Error("initializeWasm() must be awaited first!");
46255 const nativeResponseValue = wasm.TS_PaymentParameters_blinded(blinded_route_hints);
46256 return nativeResponseValue;
46258 // void Payee_free(struct LDKPayee this_ptr);
46260 export function Payee_free(this_ptr: bigint): void {
46261 if(!isWasmInitialized) {
46262 throw new Error("initializeWasm() must be awaited first!");
46264 const nativeResponseValue = wasm.TS_Payee_free(this_ptr);
46265 // debug statements here
46267 // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
46269 export function Payee_clone_ptr(arg: bigint): bigint {
46270 if(!isWasmInitialized) {
46271 throw new Error("initializeWasm() must be awaited first!");
46273 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
46274 return nativeResponseValue;
46276 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
46278 export function Payee_clone(orig: bigint): bigint {
46279 if(!isWasmInitialized) {
46280 throw new Error("initializeWasm() must be awaited first!");
46282 const nativeResponseValue = wasm.TS_Payee_clone(orig);
46283 return nativeResponseValue;
46285 // struct LDKPayee Payee_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints, struct LDKBolt12InvoiceFeatures features);
46287 export function Payee_blinded(route_hints: number, features: bigint): bigint {
46288 if(!isWasmInitialized) {
46289 throw new Error("initializeWasm() must be awaited first!");
46291 const nativeResponseValue = wasm.TS_Payee_blinded(route_hints, features);
46292 return nativeResponseValue;
46294 // struct LDKPayee Payee_clear(struct LDKPublicKey node_id, struct LDKCVec_RouteHintZ route_hints, struct LDKBolt11InvoiceFeatures features, uint32_t final_cltv_expiry_delta);
46296 export function Payee_clear(node_id: number, route_hints: number, features: bigint, final_cltv_expiry_delta: number): bigint {
46297 if(!isWasmInitialized) {
46298 throw new Error("initializeWasm() must be awaited first!");
46300 const nativeResponseValue = wasm.TS_Payee_clear(node_id, route_hints, features, final_cltv_expiry_delta);
46301 return nativeResponseValue;
46303 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
46305 export function Payee_hash(o: bigint): bigint {
46306 if(!isWasmInitialized) {
46307 throw new Error("initializeWasm() must be awaited first!");
46309 const nativeResponseValue = wasm.TS_Payee_hash(o);
46310 return nativeResponseValue;
46312 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
46314 export function Payee_eq(a: bigint, b: bigint): boolean {
46315 if(!isWasmInitialized) {
46316 throw new Error("initializeWasm() must be awaited first!");
46318 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
46319 return nativeResponseValue;
46321 // void RouteHint_free(struct LDKRouteHint this_obj);
46323 export function RouteHint_free(this_obj: bigint): void {
46324 if(!isWasmInitialized) {
46325 throw new Error("initializeWasm() must be awaited first!");
46327 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
46328 // debug statements here
46330 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
46332 export function RouteHint_get_a(this_ptr: bigint): number {
46333 if(!isWasmInitialized) {
46334 throw new Error("initializeWasm() must be awaited first!");
46336 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
46337 return nativeResponseValue;
46339 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
46341 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
46342 if(!isWasmInitialized) {
46343 throw new Error("initializeWasm() must be awaited first!");
46345 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
46346 // debug statements here
46348 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
46350 export function RouteHint_new(a_arg: number): bigint {
46351 if(!isWasmInitialized) {
46352 throw new Error("initializeWasm() must be awaited first!");
46354 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
46355 return nativeResponseValue;
46357 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
46359 export function RouteHint_clone_ptr(arg: bigint): bigint {
46360 if(!isWasmInitialized) {
46361 throw new Error("initializeWasm() must be awaited first!");
46363 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
46364 return nativeResponseValue;
46366 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
46368 export function RouteHint_clone(orig: bigint): bigint {
46369 if(!isWasmInitialized) {
46370 throw new Error("initializeWasm() must be awaited first!");
46372 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
46373 return nativeResponseValue;
46375 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
46377 export function RouteHint_hash(o: bigint): bigint {
46378 if(!isWasmInitialized) {
46379 throw new Error("initializeWasm() must be awaited first!");
46381 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
46382 return nativeResponseValue;
46384 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
46386 export function RouteHint_eq(a: bigint, b: bigint): boolean {
46387 if(!isWasmInitialized) {
46388 throw new Error("initializeWasm() must be awaited first!");
46390 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
46391 return nativeResponseValue;
46393 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
46395 export function RouteHint_write(obj: bigint): number {
46396 if(!isWasmInitialized) {
46397 throw new Error("initializeWasm() must be awaited first!");
46399 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
46400 return nativeResponseValue;
46402 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
46404 export function RouteHint_read(ser: number): bigint {
46405 if(!isWasmInitialized) {
46406 throw new Error("initializeWasm() must be awaited first!");
46408 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
46409 return nativeResponseValue;
46411 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
46413 export function RouteHintHop_free(this_obj: bigint): void {
46414 if(!isWasmInitialized) {
46415 throw new Error("initializeWasm() must be awaited first!");
46417 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
46418 // debug statements here
46420 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46422 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
46423 if(!isWasmInitialized) {
46424 throw new Error("initializeWasm() must be awaited first!");
46426 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
46427 return nativeResponseValue;
46429 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
46431 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
46432 if(!isWasmInitialized) {
46433 throw new Error("initializeWasm() must be awaited first!");
46435 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
46436 // debug statements here
46438 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46440 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
46441 if(!isWasmInitialized) {
46442 throw new Error("initializeWasm() must be awaited first!");
46444 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
46445 return nativeResponseValue;
46447 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
46449 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
46450 if(!isWasmInitialized) {
46451 throw new Error("initializeWasm() must be awaited first!");
46453 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
46454 // debug statements here
46456 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46458 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
46459 if(!isWasmInitialized) {
46460 throw new Error("initializeWasm() must be awaited first!");
46462 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
46463 return nativeResponseValue;
46465 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
46467 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
46468 if(!isWasmInitialized) {
46469 throw new Error("initializeWasm() must be awaited first!");
46471 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
46472 // debug statements here
46474 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46476 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
46477 if(!isWasmInitialized) {
46478 throw new Error("initializeWasm() must be awaited first!");
46480 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
46481 return nativeResponseValue;
46483 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
46485 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
46486 if(!isWasmInitialized) {
46487 throw new Error("initializeWasm() must be awaited first!");
46489 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
46490 // debug statements here
46492 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46494 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
46495 if(!isWasmInitialized) {
46496 throw new Error("initializeWasm() must be awaited first!");
46498 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
46499 return nativeResponseValue;
46501 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
46503 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
46504 if(!isWasmInitialized) {
46505 throw new Error("initializeWasm() must be awaited first!");
46507 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
46508 // debug statements here
46510 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46512 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
46513 if(!isWasmInitialized) {
46514 throw new Error("initializeWasm() must be awaited first!");
46516 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
46517 return nativeResponseValue;
46519 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
46521 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
46522 if(!isWasmInitialized) {
46523 throw new Error("initializeWasm() must be awaited first!");
46525 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
46526 // debug statements here
46528 // 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);
46530 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 {
46531 if(!isWasmInitialized) {
46532 throw new Error("initializeWasm() must be awaited first!");
46534 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);
46535 return nativeResponseValue;
46537 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
46539 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
46540 if(!isWasmInitialized) {
46541 throw new Error("initializeWasm() must be awaited first!");
46543 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
46544 return nativeResponseValue;
46546 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
46548 export function RouteHintHop_clone(orig: bigint): bigint {
46549 if(!isWasmInitialized) {
46550 throw new Error("initializeWasm() must be awaited first!");
46552 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
46553 return nativeResponseValue;
46555 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
46557 export function RouteHintHop_hash(o: bigint): bigint {
46558 if(!isWasmInitialized) {
46559 throw new Error("initializeWasm() must be awaited first!");
46561 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
46562 return nativeResponseValue;
46564 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
46566 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
46567 if(!isWasmInitialized) {
46568 throw new Error("initializeWasm() must be awaited first!");
46570 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
46571 return nativeResponseValue;
46573 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
46575 export function RouteHintHop_write(obj: bigint): number {
46576 if(!isWasmInitialized) {
46577 throw new Error("initializeWasm() must be awaited first!");
46579 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
46580 return nativeResponseValue;
46582 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
46584 export function RouteHintHop_read(ser: number): bigint {
46585 if(!isWasmInitialized) {
46586 throw new Error("initializeWasm() must be awaited first!");
46588 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
46589 return nativeResponseValue;
46591 // 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 LDKScoreLookUp *NONNULL_PTR scorer, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params, const uint8_t (*random_seed_bytes)[32]);
46593 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 {
46594 if(!isWasmInitialized) {
46595 throw new Error("initializeWasm() must be awaited first!");
46597 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, score_params, random_seed_bytes);
46598 return nativeResponseValue;
46600 // 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]);
46602 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 {
46603 if(!isWasmInitialized) {
46604 throw new Error("initializeWasm() must be awaited first!");
46606 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
46607 return nativeResponseValue;
46609 // void ScoreLookUp_free(struct LDKScoreLookUp this_ptr);
46611 export function ScoreLookUp_free(this_ptr: bigint): void {
46612 if(!isWasmInitialized) {
46613 throw new Error("initializeWasm() must be awaited first!");
46615 const nativeResponseValue = wasm.TS_ScoreLookUp_free(this_ptr);
46616 // debug statements here
46618 // void ScoreUpdate_free(struct LDKScoreUpdate this_ptr);
46620 export function ScoreUpdate_free(this_ptr: bigint): void {
46621 if(!isWasmInitialized) {
46622 throw new Error("initializeWasm() must be awaited first!");
46624 const nativeResponseValue = wasm.TS_ScoreUpdate_free(this_ptr);
46625 // debug statements here
46627 // void Score_free(struct LDKScore this_ptr);
46629 export function Score_free(this_ptr: bigint): void {
46630 if(!isWasmInitialized) {
46631 throw new Error("initializeWasm() must be awaited first!");
46633 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
46634 // debug statements here
46636 // void LockableScore_free(struct LDKLockableScore this_ptr);
46638 export function LockableScore_free(this_ptr: bigint): void {
46639 if(!isWasmInitialized) {
46640 throw new Error("initializeWasm() must be awaited first!");
46642 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
46643 // debug statements here
46645 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
46647 export function WriteableScore_free(this_ptr: bigint): void {
46648 if(!isWasmInitialized) {
46649 throw new Error("initializeWasm() must be awaited first!");
46651 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
46652 // debug statements here
46654 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
46656 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
46657 if(!isWasmInitialized) {
46658 throw new Error("initializeWasm() must be awaited first!");
46660 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
46661 // debug statements here
46663 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
46665 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
46666 if(!isWasmInitialized) {
46667 throw new Error("initializeWasm() must be awaited first!");
46669 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
46670 return nativeResponseValue;
46672 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
46674 export function MultiThreadedLockableScore_write(obj: bigint): number {
46675 if(!isWasmInitialized) {
46676 throw new Error("initializeWasm() must be awaited first!");
46678 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
46679 return nativeResponseValue;
46681 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
46683 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
46684 if(!isWasmInitialized) {
46685 throw new Error("initializeWasm() must be awaited first!");
46687 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
46688 return nativeResponseValue;
46690 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
46692 export function MultiThreadedLockableScore_new(score: bigint): bigint {
46693 if(!isWasmInitialized) {
46694 throw new Error("initializeWasm() must be awaited first!");
46696 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
46697 return nativeResponseValue;
46699 // void MultiThreadedScoreLockRead_free(struct LDKMultiThreadedScoreLockRead this_obj);
46701 export function MultiThreadedScoreLockRead_free(this_obj: bigint): void {
46702 if(!isWasmInitialized) {
46703 throw new Error("initializeWasm() must be awaited first!");
46705 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_free(this_obj);
46706 // debug statements here
46708 // void MultiThreadedScoreLockWrite_free(struct LDKMultiThreadedScoreLockWrite this_obj);
46710 export function MultiThreadedScoreLockWrite_free(this_obj: bigint): void {
46711 if(!isWasmInitialized) {
46712 throw new Error("initializeWasm() must be awaited first!");
46714 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_free(this_obj);
46715 // debug statements here
46717 // struct LDKScoreLookUp MultiThreadedScoreLockRead_as_ScoreLookUp(const struct LDKMultiThreadedScoreLockRead *NONNULL_PTR this_arg);
46719 export function MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg: bigint): bigint {
46720 if(!isWasmInitialized) {
46721 throw new Error("initializeWasm() must be awaited first!");
46723 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg);
46724 return nativeResponseValue;
46726 // struct LDKCVec_u8Z MultiThreadedScoreLockWrite_write(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR obj);
46728 export function MultiThreadedScoreLockWrite_write(obj: bigint): number {
46729 if(!isWasmInitialized) {
46730 throw new Error("initializeWasm() must be awaited first!");
46732 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_write(obj);
46733 return nativeResponseValue;
46735 // struct LDKScoreUpdate MultiThreadedScoreLockWrite_as_ScoreUpdate(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR this_arg);
46737 export function MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg: bigint): bigint {
46738 if(!isWasmInitialized) {
46739 throw new Error("initializeWasm() must be awaited first!");
46741 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg);
46742 return nativeResponseValue;
46744 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
46746 export function ChannelUsage_free(this_obj: bigint): void {
46747 if(!isWasmInitialized) {
46748 throw new Error("initializeWasm() must be awaited first!");
46750 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
46751 // debug statements here
46753 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
46755 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
46756 if(!isWasmInitialized) {
46757 throw new Error("initializeWasm() must be awaited first!");
46759 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
46760 return nativeResponseValue;
46762 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
46764 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
46765 if(!isWasmInitialized) {
46766 throw new Error("initializeWasm() must be awaited first!");
46768 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
46769 // debug statements here
46771 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
46773 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
46774 if(!isWasmInitialized) {
46775 throw new Error("initializeWasm() must be awaited first!");
46777 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
46778 return nativeResponseValue;
46780 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
46782 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
46783 if(!isWasmInitialized) {
46784 throw new Error("initializeWasm() must be awaited first!");
46786 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
46787 // debug statements here
46789 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
46791 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
46792 if(!isWasmInitialized) {
46793 throw new Error("initializeWasm() must be awaited first!");
46795 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
46796 return nativeResponseValue;
46798 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
46800 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
46801 if(!isWasmInitialized) {
46802 throw new Error("initializeWasm() must be awaited first!");
46804 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
46805 // debug statements here
46807 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
46809 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
46810 if(!isWasmInitialized) {
46811 throw new Error("initializeWasm() must be awaited first!");
46813 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
46814 return nativeResponseValue;
46816 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
46818 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
46819 if(!isWasmInitialized) {
46820 throw new Error("initializeWasm() must be awaited first!");
46822 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
46823 return nativeResponseValue;
46825 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
46827 export function ChannelUsage_clone(orig: bigint): bigint {
46828 if(!isWasmInitialized) {
46829 throw new Error("initializeWasm() must be awaited first!");
46831 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
46832 return nativeResponseValue;
46834 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
46836 export function FixedPenaltyScorer_free(this_obj: bigint): void {
46837 if(!isWasmInitialized) {
46838 throw new Error("initializeWasm() must be awaited first!");
46840 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
46841 // debug statements here
46843 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
46845 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
46846 if(!isWasmInitialized) {
46847 throw new Error("initializeWasm() must be awaited first!");
46849 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
46850 return nativeResponseValue;
46852 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
46854 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
46855 if(!isWasmInitialized) {
46856 throw new Error("initializeWasm() must be awaited first!");
46858 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
46859 return nativeResponseValue;
46861 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
46863 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
46864 if(!isWasmInitialized) {
46865 throw new Error("initializeWasm() must be awaited first!");
46867 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
46868 return nativeResponseValue;
46870 // struct LDKScoreLookUp FixedPenaltyScorer_as_ScoreLookUp(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
46872 export function FixedPenaltyScorer_as_ScoreLookUp(this_arg: bigint): bigint {
46873 if(!isWasmInitialized) {
46874 throw new Error("initializeWasm() must be awaited first!");
46876 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreLookUp(this_arg);
46877 return nativeResponseValue;
46879 // struct LDKScoreUpdate FixedPenaltyScorer_as_ScoreUpdate(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
46881 export function FixedPenaltyScorer_as_ScoreUpdate(this_arg: bigint): bigint {
46882 if(!isWasmInitialized) {
46883 throw new Error("initializeWasm() must be awaited first!");
46885 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreUpdate(this_arg);
46886 return nativeResponseValue;
46888 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
46890 export function FixedPenaltyScorer_write(obj: bigint): number {
46891 if(!isWasmInitialized) {
46892 throw new Error("initializeWasm() must be awaited first!");
46894 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
46895 return nativeResponseValue;
46897 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
46899 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
46900 if(!isWasmInitialized) {
46901 throw new Error("initializeWasm() must be awaited first!");
46903 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
46904 return nativeResponseValue;
46906 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
46908 export function ProbabilisticScorer_free(this_obj: bigint): void {
46909 if(!isWasmInitialized) {
46910 throw new Error("initializeWasm() must be awaited first!");
46912 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
46913 // debug statements here
46915 // void ProbabilisticScoringFeeParameters_free(struct LDKProbabilisticScoringFeeParameters this_obj);
46917 export function ProbabilisticScoringFeeParameters_free(this_obj: bigint): void {
46918 if(!isWasmInitialized) {
46919 throw new Error("initializeWasm() must be awaited first!");
46921 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_free(this_obj);
46922 // debug statements here
46924 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
46926 export function ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
46927 if(!isWasmInitialized) {
46928 throw new Error("initializeWasm() must be awaited first!");
46930 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr);
46931 return nativeResponseValue;
46933 // void ProbabilisticScoringFeeParameters_set_base_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
46935 export function ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
46936 if(!isWasmInitialized) {
46937 throw new Error("initializeWasm() must be awaited first!");
46939 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr, val);
46940 // debug statements here
46942 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
46944 export function ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
46945 if(!isWasmInitialized) {
46946 throw new Error("initializeWasm() must be awaited first!");
46948 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
46949 return nativeResponseValue;
46951 // void ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
46953 export function ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
46954 if(!isWasmInitialized) {
46955 throw new Error("initializeWasm() must be awaited first!");
46957 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
46958 // debug statements here
46960 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
46962 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
46963 if(!isWasmInitialized) {
46964 throw new Error("initializeWasm() must be awaited first!");
46966 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
46967 return nativeResponseValue;
46969 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
46971 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
46972 if(!isWasmInitialized) {
46973 throw new Error("initializeWasm() must be awaited first!");
46975 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
46976 // debug statements here
46978 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
46980 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
46981 if(!isWasmInitialized) {
46982 throw new Error("initializeWasm() must be awaited first!");
46984 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
46985 return nativeResponseValue;
46987 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
46989 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
46990 if(!isWasmInitialized) {
46991 throw new Error("initializeWasm() must be awaited first!");
46993 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
46994 // debug statements here
46996 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
46998 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
46999 if(!isWasmInitialized) {
47000 throw new Error("initializeWasm() must be awaited first!");
47002 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
47003 return nativeResponseValue;
47005 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47007 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
47008 if(!isWasmInitialized) {
47009 throw new Error("initializeWasm() must be awaited first!");
47011 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
47012 // debug statements here
47014 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47016 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
47017 if(!isWasmInitialized) {
47018 throw new Error("initializeWasm() must be awaited first!");
47020 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
47021 return nativeResponseValue;
47023 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47025 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
47026 if(!isWasmInitialized) {
47027 throw new Error("initializeWasm() must be awaited first!");
47029 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
47030 // debug statements here
47032 // uint64_t ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47034 export function ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
47035 if(!isWasmInitialized) {
47036 throw new Error("initializeWasm() must be awaited first!");
47038 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr);
47039 return nativeResponseValue;
47041 // void ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47043 export function ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
47044 if(!isWasmInitialized) {
47045 throw new Error("initializeWasm() must be awaited first!");
47047 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr, val);
47048 // debug statements here
47050 // uint64_t ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47052 export function ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
47053 if(!isWasmInitialized) {
47054 throw new Error("initializeWasm() must be awaited first!");
47056 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr);
47057 return nativeResponseValue;
47059 // void ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47061 export function ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
47062 if(!isWasmInitialized) {
47063 throw new Error("initializeWasm() must be awaited first!");
47065 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr, val);
47066 // debug statements here
47068 // bool ProbabilisticScoringFeeParameters_get_linear_success_probability(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47070 export function ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr: bigint): boolean {
47071 if(!isWasmInitialized) {
47072 throw new Error("initializeWasm() must be awaited first!");
47074 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr);
47075 return nativeResponseValue;
47077 // void ProbabilisticScoringFeeParameters_set_linear_success_probability(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, bool val);
47079 export function ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr: bigint, val: boolean): void {
47080 if(!isWasmInitialized) {
47081 throw new Error("initializeWasm() must be awaited first!");
47083 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr, val);
47084 // debug statements here
47086 // uint64_t ProbabilisticScoringFeeParameters_clone_ptr(LDKProbabilisticScoringFeeParameters *NONNULL_PTR arg);
47088 export function ProbabilisticScoringFeeParameters_clone_ptr(arg: bigint): bigint {
47089 if(!isWasmInitialized) {
47090 throw new Error("initializeWasm() must be awaited first!");
47092 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone_ptr(arg);
47093 return nativeResponseValue;
47095 // struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_clone(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR orig);
47097 export function ProbabilisticScoringFeeParameters_clone(orig: bigint): bigint {
47098 if(!isWasmInitialized) {
47099 throw new Error("initializeWasm() must be awaited first!");
47101 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone(orig);
47102 return nativeResponseValue;
47104 // MUST_USE_RES struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_default(void);
47106 export function ProbabilisticScoringFeeParameters_default(): bigint {
47107 if(!isWasmInitialized) {
47108 throw new Error("initializeWasm() must be awaited first!");
47110 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_default();
47111 return nativeResponseValue;
47113 // void ProbabilisticScoringFeeParameters_add_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
47115 export function ProbabilisticScoringFeeParameters_add_banned(this_arg: bigint, node_id: bigint): void {
47116 if(!isWasmInitialized) {
47117 throw new Error("initializeWasm() must be awaited first!");
47119 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned(this_arg, node_id);
47120 // debug statements here
47122 // void ProbabilisticScoringFeeParameters_add_banned_from_list(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
47124 export function ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
47125 if(!isWasmInitialized) {
47126 throw new Error("initializeWasm() must be awaited first!");
47128 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg, node_ids);
47129 // debug statements here
47131 // void ProbabilisticScoringFeeParameters_remove_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
47133 export function ProbabilisticScoringFeeParameters_remove_banned(this_arg: bigint, node_id: bigint): void {
47134 if(!isWasmInitialized) {
47135 throw new Error("initializeWasm() must be awaited first!");
47137 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_banned(this_arg, node_id);
47138 // debug statements here
47140 // void ProbabilisticScoringFeeParameters_set_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
47142 export function ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
47143 if(!isWasmInitialized) {
47144 throw new Error("initializeWasm() must be awaited first!");
47146 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg, node_id, penalty);
47147 // debug statements here
47149 // void ProbabilisticScoringFeeParameters_remove_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
47151 export function ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
47152 if(!isWasmInitialized) {
47153 throw new Error("initializeWasm() must be awaited first!");
47155 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg, node_id);
47156 // debug statements here
47158 // void ProbabilisticScoringFeeParameters_clear_manual_penalties(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg);
47160 export function ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg: bigint): void {
47161 if(!isWasmInitialized) {
47162 throw new Error("initializeWasm() must be awaited first!");
47164 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg);
47165 // debug statements here
47167 // void ProbabilisticScoringDecayParameters_free(struct LDKProbabilisticScoringDecayParameters this_obj);
47169 export function ProbabilisticScoringDecayParameters_free(this_obj: bigint): void {
47170 if(!isWasmInitialized) {
47171 throw new Error("initializeWasm() must be awaited first!");
47173 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_free(this_obj);
47174 // debug statements here
47176 // uint64_t ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
47178 export function ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
47179 if(!isWasmInitialized) {
47180 throw new Error("initializeWasm() must be awaited first!");
47182 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr);
47183 return nativeResponseValue;
47185 // void ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
47187 export function ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
47188 if(!isWasmInitialized) {
47189 throw new Error("initializeWasm() must be awaited first!");
47191 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr, val);
47192 // debug statements here
47194 // uint64_t ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
47196 export function ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
47197 if(!isWasmInitialized) {
47198 throw new Error("initializeWasm() must be awaited first!");
47200 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr);
47201 return nativeResponseValue;
47203 // void ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
47205 export function ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
47206 if(!isWasmInitialized) {
47207 throw new Error("initializeWasm() must be awaited first!");
47209 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr, val);
47210 // debug statements here
47212 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_new(uint64_t historical_no_updates_half_life_arg, uint64_t liquidity_offset_half_life_arg);
47214 export function ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg: bigint, liquidity_offset_half_life_arg: bigint): bigint {
47215 if(!isWasmInitialized) {
47216 throw new Error("initializeWasm() must be awaited first!");
47218 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg, liquidity_offset_half_life_arg);
47219 return nativeResponseValue;
47221 // uint64_t ProbabilisticScoringDecayParameters_clone_ptr(LDKProbabilisticScoringDecayParameters *NONNULL_PTR arg);
47223 export function ProbabilisticScoringDecayParameters_clone_ptr(arg: bigint): bigint {
47224 if(!isWasmInitialized) {
47225 throw new Error("initializeWasm() must be awaited first!");
47227 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone_ptr(arg);
47228 return nativeResponseValue;
47230 // struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_clone(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR orig);
47232 export function ProbabilisticScoringDecayParameters_clone(orig: bigint): bigint {
47233 if(!isWasmInitialized) {
47234 throw new Error("initializeWasm() must be awaited first!");
47236 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone(orig);
47237 return nativeResponseValue;
47239 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_default(void);
47241 export function ProbabilisticScoringDecayParameters_default(): bigint {
47242 if(!isWasmInitialized) {
47243 throw new Error("initializeWasm() must be awaited first!");
47245 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_default();
47246 return nativeResponseValue;
47248 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringDecayParameters decay_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
47250 export function ProbabilisticScorer_new(decay_params: bigint, network_graph: bigint, logger: bigint): bigint {
47251 if(!isWasmInitialized) {
47252 throw new Error("initializeWasm() must be awaited first!");
47254 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(decay_params, network_graph, logger);
47255 return nativeResponseValue;
47257 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47259 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
47260 if(!isWasmInitialized) {
47261 throw new Error("initializeWasm() must be awaited first!");
47263 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
47264 // debug statements here
47266 // 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);
47268 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
47269 if(!isWasmInitialized) {
47270 throw new Error("initializeWasm() must be awaited first!");
47272 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
47273 return nativeResponseValue;
47275 // MUST_USE_RES struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
47277 export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
47278 if(!isWasmInitialized) {
47279 throw new Error("initializeWasm() must be awaited first!");
47281 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
47282 return nativeResponseValue;
47284 // MUST_USE_RES struct LDKCOption_f64Z ProbabilisticScorer_historical_estimated_payment_success_probability(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target, uint64_t amount_msat, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR params);
47286 export function ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg: bigint, scid: bigint, target: bigint, amount_msat: bigint, params: bigint): bigint {
47287 if(!isWasmInitialized) {
47288 throw new Error("initializeWasm() must be awaited first!");
47290 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg, scid, target, amount_msat, params);
47291 return nativeResponseValue;
47293 // struct LDKScoreLookUp ProbabilisticScorer_as_ScoreLookUp(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47295 export function ProbabilisticScorer_as_ScoreLookUp(this_arg: bigint): bigint {
47296 if(!isWasmInitialized) {
47297 throw new Error("initializeWasm() must be awaited first!");
47299 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreLookUp(this_arg);
47300 return nativeResponseValue;
47302 // struct LDKScoreUpdate ProbabilisticScorer_as_ScoreUpdate(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47304 export function ProbabilisticScorer_as_ScoreUpdate(this_arg: bigint): bigint {
47305 if(!isWasmInitialized) {
47306 throw new Error("initializeWasm() must be awaited first!");
47308 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreUpdate(this_arg);
47309 return nativeResponseValue;
47311 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47313 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
47314 if(!isWasmInitialized) {
47315 throw new Error("initializeWasm() must be awaited first!");
47317 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
47318 return nativeResponseValue;
47320 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
47322 export function ProbabilisticScorer_write(obj: bigint): number {
47323 if(!isWasmInitialized) {
47324 throw new Error("initializeWasm() must be awaited first!");
47326 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
47327 return nativeResponseValue;
47329 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringDecayParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
47331 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
47332 if(!isWasmInitialized) {
47333 throw new Error("initializeWasm() must be awaited first!");
47335 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
47336 return nativeResponseValue;
47338 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
47340 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
47341 if(!isWasmInitialized) {
47342 throw new Error("initializeWasm() must be awaited first!");
47344 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
47345 // debug statements here
47347 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47349 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
47350 if(!isWasmInitialized) {
47351 throw new Error("initializeWasm() must be awaited first!");
47353 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
47354 return nativeResponseValue;
47356 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
47358 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
47359 if(!isWasmInitialized) {
47360 throw new Error("initializeWasm() must be awaited first!");
47362 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
47363 // debug statements here
47365 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47367 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
47368 if(!isWasmInitialized) {
47369 throw new Error("initializeWasm() must be awaited first!");
47371 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
47372 return nativeResponseValue;
47374 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
47376 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
47377 if(!isWasmInitialized) {
47378 throw new Error("initializeWasm() must be awaited first!");
47380 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
47381 // debug statements here
47383 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47385 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
47386 if(!isWasmInitialized) {
47387 throw new Error("initializeWasm() must be awaited first!");
47389 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
47390 return nativeResponseValue;
47392 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
47394 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
47395 if(!isWasmInitialized) {
47396 throw new Error("initializeWasm() must be awaited first!");
47398 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
47399 // debug statements here
47401 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47403 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
47404 if(!isWasmInitialized) {
47405 throw new Error("initializeWasm() must be awaited first!");
47407 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
47408 return nativeResponseValue;
47410 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
47412 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
47413 if(!isWasmInitialized) {
47414 throw new Error("initializeWasm() must be awaited first!");
47416 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
47417 // debug statements here
47419 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47421 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
47422 if(!isWasmInitialized) {
47423 throw new Error("initializeWasm() must be awaited first!");
47425 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
47426 return nativeResponseValue;
47428 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
47430 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
47431 if(!isWasmInitialized) {
47432 throw new Error("initializeWasm() must be awaited first!");
47434 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
47435 // debug statements here
47437 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
47439 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
47440 if(!isWasmInitialized) {
47441 throw new Error("initializeWasm() must be awaited first!");
47443 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
47444 return nativeResponseValue;
47446 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
47448 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
47449 if(!isWasmInitialized) {
47450 throw new Error("initializeWasm() must be awaited first!");
47452 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
47453 // debug statements here
47455 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47457 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
47458 if(!isWasmInitialized) {
47459 throw new Error("initializeWasm() must be awaited first!");
47461 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
47462 return nativeResponseValue;
47464 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
47466 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
47467 if(!isWasmInitialized) {
47468 throw new Error("initializeWasm() must be awaited first!");
47470 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
47471 // debug statements here
47473 // 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);
47475 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 {
47476 if(!isWasmInitialized) {
47477 throw new Error("initializeWasm() must be awaited first!");
47479 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);
47480 return nativeResponseValue;
47482 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
47484 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
47485 if(!isWasmInitialized) {
47486 throw new Error("initializeWasm() must be awaited first!");
47488 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
47489 return nativeResponseValue;
47491 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
47493 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
47494 if(!isWasmInitialized) {
47495 throw new Error("initializeWasm() must be awaited first!");
47497 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
47498 return nativeResponseValue;
47500 // uint64_t DelayedPaymentOutputDescriptor_hash(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR o);
47502 export function DelayedPaymentOutputDescriptor_hash(o: bigint): bigint {
47503 if(!isWasmInitialized) {
47504 throw new Error("initializeWasm() must be awaited first!");
47506 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_hash(o);
47507 return nativeResponseValue;
47509 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
47511 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
47512 if(!isWasmInitialized) {
47513 throw new Error("initializeWasm() must be awaited first!");
47515 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
47516 return nativeResponseValue;
47518 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
47520 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
47521 if(!isWasmInitialized) {
47522 throw new Error("initializeWasm() must be awaited first!");
47524 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
47525 return nativeResponseValue;
47527 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
47529 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
47530 if(!isWasmInitialized) {
47531 throw new Error("initializeWasm() must be awaited first!");
47533 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
47534 return nativeResponseValue;
47536 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
47538 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
47539 if(!isWasmInitialized) {
47540 throw new Error("initializeWasm() must be awaited first!");
47542 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
47543 // debug statements here
47545 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47547 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
47548 if(!isWasmInitialized) {
47549 throw new Error("initializeWasm() must be awaited first!");
47551 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
47552 return nativeResponseValue;
47554 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
47556 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
47557 if(!isWasmInitialized) {
47558 throw new Error("initializeWasm() must be awaited first!");
47560 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
47561 // debug statements here
47563 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47565 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
47566 if(!isWasmInitialized) {
47567 throw new Error("initializeWasm() must be awaited first!");
47569 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
47570 return nativeResponseValue;
47572 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
47574 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
47575 if(!isWasmInitialized) {
47576 throw new Error("initializeWasm() must be awaited first!");
47578 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
47579 // debug statements here
47581 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
47583 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
47584 if(!isWasmInitialized) {
47585 throw new Error("initializeWasm() must be awaited first!");
47587 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
47588 return nativeResponseValue;
47590 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
47592 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
47593 if(!isWasmInitialized) {
47594 throw new Error("initializeWasm() must be awaited first!");
47596 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
47597 // debug statements here
47599 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47601 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
47602 if(!isWasmInitialized) {
47603 throw new Error("initializeWasm() must be awaited first!");
47605 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
47606 return nativeResponseValue;
47608 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
47610 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
47611 if(!isWasmInitialized) {
47612 throw new Error("initializeWasm() must be awaited first!");
47614 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
47615 // debug statements here
47617 // struct LDKChannelTransactionParameters StaticPaymentOutputDescriptor_get_channel_transaction_parameters(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47619 export function StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr: bigint): bigint {
47620 if(!isWasmInitialized) {
47621 throw new Error("initializeWasm() must be awaited first!");
47623 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr);
47624 return nativeResponseValue;
47626 // void StaticPaymentOutputDescriptor_set_channel_transaction_parameters(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
47628 export function StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr: bigint, val: bigint): void {
47629 if(!isWasmInitialized) {
47630 throw new Error("initializeWasm() must be awaited first!");
47632 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr, val);
47633 // debug statements here
47635 // 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, struct LDKChannelTransactionParameters channel_transaction_parameters_arg);
47637 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint, channel_transaction_parameters_arg: bigint): bigint {
47638 if(!isWasmInitialized) {
47639 throw new Error("initializeWasm() must be awaited first!");
47641 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg, channel_transaction_parameters_arg);
47642 return nativeResponseValue;
47644 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
47646 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
47647 if(!isWasmInitialized) {
47648 throw new Error("initializeWasm() must be awaited first!");
47650 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
47651 return nativeResponseValue;
47653 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
47655 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
47656 if(!isWasmInitialized) {
47657 throw new Error("initializeWasm() must be awaited first!");
47659 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
47660 return nativeResponseValue;
47662 // uint64_t StaticPaymentOutputDescriptor_hash(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR o);
47664 export function StaticPaymentOutputDescriptor_hash(o: bigint): bigint {
47665 if(!isWasmInitialized) {
47666 throw new Error("initializeWasm() must be awaited first!");
47668 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_hash(o);
47669 return nativeResponseValue;
47671 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
47673 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
47674 if(!isWasmInitialized) {
47675 throw new Error("initializeWasm() must be awaited first!");
47677 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
47678 return nativeResponseValue;
47680 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ StaticPaymentOutputDescriptor_witness_script(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
47682 export function StaticPaymentOutputDescriptor_witness_script(this_arg: bigint): bigint {
47683 if(!isWasmInitialized) {
47684 throw new Error("initializeWasm() must be awaited first!");
47686 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_witness_script(this_arg);
47687 return nativeResponseValue;
47689 // MUST_USE_RES uintptr_t StaticPaymentOutputDescriptor_max_witness_length(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
47691 export function StaticPaymentOutputDescriptor_max_witness_length(this_arg: bigint): number {
47692 if(!isWasmInitialized) {
47693 throw new Error("initializeWasm() must be awaited first!");
47695 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_max_witness_length(this_arg);
47696 return nativeResponseValue;
47698 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
47700 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
47701 if(!isWasmInitialized) {
47702 throw new Error("initializeWasm() must be awaited first!");
47704 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
47705 return nativeResponseValue;
47707 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
47709 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
47710 if(!isWasmInitialized) {
47711 throw new Error("initializeWasm() must be awaited first!");
47713 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
47714 return nativeResponseValue;
47716 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
47718 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
47719 if(!isWasmInitialized) {
47720 throw new Error("initializeWasm() must be awaited first!");
47722 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
47723 // debug statements here
47725 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
47727 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
47728 if(!isWasmInitialized) {
47729 throw new Error("initializeWasm() must be awaited first!");
47731 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
47732 return nativeResponseValue;
47734 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
47736 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
47737 if(!isWasmInitialized) {
47738 throw new Error("initializeWasm() must be awaited first!");
47740 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
47741 return nativeResponseValue;
47743 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
47745 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
47746 if(!isWasmInitialized) {
47747 throw new Error("initializeWasm() must be awaited first!");
47749 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
47750 return nativeResponseValue;
47752 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
47754 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
47755 if(!isWasmInitialized) {
47756 throw new Error("initializeWasm() must be awaited first!");
47758 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
47759 return nativeResponseValue;
47761 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
47763 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
47764 if(!isWasmInitialized) {
47765 throw new Error("initializeWasm() must be awaited first!");
47767 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
47768 return nativeResponseValue;
47770 // uint64_t SpendableOutputDescriptor_hash(const struct LDKSpendableOutputDescriptor *NONNULL_PTR o);
47772 export function SpendableOutputDescriptor_hash(o: bigint): bigint {
47773 if(!isWasmInitialized) {
47774 throw new Error("initializeWasm() must be awaited first!");
47776 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_hash(o);
47777 return nativeResponseValue;
47779 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
47781 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
47782 if(!isWasmInitialized) {
47783 throw new Error("initializeWasm() must be awaited first!");
47785 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
47786 return nativeResponseValue;
47788 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
47790 export function SpendableOutputDescriptor_write(obj: bigint): number {
47791 if(!isWasmInitialized) {
47792 throw new Error("initializeWasm() must be awaited first!");
47794 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
47795 return nativeResponseValue;
47797 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
47799 export function SpendableOutputDescriptor_read(ser: number): bigint {
47800 if(!isWasmInitialized) {
47801 throw new Error("initializeWasm() must be awaited first!");
47803 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
47804 return nativeResponseValue;
47806 // MUST_USE_RES struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ 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_u32Z locktime);
47808 export function SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
47809 if(!isWasmInitialized) {
47810 throw new Error("initializeWasm() must be awaited first!");
47812 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
47813 return nativeResponseValue;
47815 // void ChannelSigner_free(struct LDKChannelSigner this_ptr);
47817 export function ChannelSigner_free(this_ptr: bigint): void {
47818 if(!isWasmInitialized) {
47819 throw new Error("initializeWasm() must be awaited first!");
47821 const nativeResponseValue = wasm.TS_ChannelSigner_free(this_ptr);
47822 // debug statements here
47824 // void EcdsaChannelSigner_free(struct LDKEcdsaChannelSigner this_ptr);
47826 export function EcdsaChannelSigner_free(this_ptr: bigint): void {
47827 if(!isWasmInitialized) {
47828 throw new Error("initializeWasm() must be awaited first!");
47830 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_free(this_ptr);
47831 // debug statements here
47833 // uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg);
47835 export function WriteableEcdsaChannelSigner_clone_ptr(arg: bigint): bigint {
47836 if(!isWasmInitialized) {
47837 throw new Error("initializeWasm() must be awaited first!");
47839 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone_ptr(arg);
47840 return nativeResponseValue;
47842 // struct LDKWriteableEcdsaChannelSigner WriteableEcdsaChannelSigner_clone(const struct LDKWriteableEcdsaChannelSigner *NONNULL_PTR orig);
47844 export function WriteableEcdsaChannelSigner_clone(orig: bigint): bigint {
47845 if(!isWasmInitialized) {
47846 throw new Error("initializeWasm() must be awaited first!");
47848 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone(orig);
47849 return nativeResponseValue;
47851 // void WriteableEcdsaChannelSigner_free(struct LDKWriteableEcdsaChannelSigner this_ptr);
47853 export function WriteableEcdsaChannelSigner_free(this_ptr: bigint): void {
47854 if(!isWasmInitialized) {
47855 throw new Error("initializeWasm() must be awaited first!");
47857 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_free(this_ptr);
47858 // debug statements here
47860 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
47862 export function Recipient_clone(orig: bigint): Recipient {
47863 if(!isWasmInitialized) {
47864 throw new Error("initializeWasm() must be awaited first!");
47866 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
47867 return nativeResponseValue;
47869 // enum LDKRecipient Recipient_node(void);
47871 export function Recipient_node(): Recipient {
47872 if(!isWasmInitialized) {
47873 throw new Error("initializeWasm() must be awaited first!");
47875 const nativeResponseValue = wasm.TS_Recipient_node();
47876 return nativeResponseValue;
47878 // enum LDKRecipient Recipient_phantom_node(void);
47880 export function Recipient_phantom_node(): Recipient {
47881 if(!isWasmInitialized) {
47882 throw new Error("initializeWasm() must be awaited first!");
47884 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
47885 return nativeResponseValue;
47887 // void EntropySource_free(struct LDKEntropySource this_ptr);
47889 export function EntropySource_free(this_ptr: bigint): void {
47890 if(!isWasmInitialized) {
47891 throw new Error("initializeWasm() must be awaited first!");
47893 const nativeResponseValue = wasm.TS_EntropySource_free(this_ptr);
47894 // debug statements here
47896 // void NodeSigner_free(struct LDKNodeSigner this_ptr);
47898 export function NodeSigner_free(this_ptr: bigint): void {
47899 if(!isWasmInitialized) {
47900 throw new Error("initializeWasm() must be awaited first!");
47902 const nativeResponseValue = wasm.TS_NodeSigner_free(this_ptr);
47903 // debug statements here
47905 // void SignerProvider_free(struct LDKSignerProvider this_ptr);
47907 export function SignerProvider_free(this_ptr: bigint): void {
47908 if(!isWasmInitialized) {
47909 throw new Error("initializeWasm() must be awaited first!");
47911 const nativeResponseValue = wasm.TS_SignerProvider_free(this_ptr);
47912 // debug statements here
47914 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
47916 export function InMemorySigner_free(this_obj: bigint): void {
47917 if(!isWasmInitialized) {
47918 throw new Error("initializeWasm() must be awaited first!");
47920 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
47921 // debug statements here
47923 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
47925 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
47926 if(!isWasmInitialized) {
47927 throw new Error("initializeWasm() must be awaited first!");
47929 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
47930 return nativeResponseValue;
47932 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
47934 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
47935 if(!isWasmInitialized) {
47936 throw new Error("initializeWasm() must be awaited first!");
47938 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
47939 // debug statements here
47941 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
47943 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
47944 if(!isWasmInitialized) {
47945 throw new Error("initializeWasm() must be awaited first!");
47947 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
47948 return nativeResponseValue;
47950 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
47952 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
47953 if(!isWasmInitialized) {
47954 throw new Error("initializeWasm() must be awaited first!");
47956 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
47957 // debug statements here
47959 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
47961 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
47962 if(!isWasmInitialized) {
47963 throw new Error("initializeWasm() must be awaited first!");
47965 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
47966 return nativeResponseValue;
47968 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
47970 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
47971 if(!isWasmInitialized) {
47972 throw new Error("initializeWasm() must be awaited first!");
47974 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
47975 // debug statements here
47977 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
47979 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
47980 if(!isWasmInitialized) {
47981 throw new Error("initializeWasm() must be awaited first!");
47983 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
47984 return nativeResponseValue;
47986 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
47988 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
47989 if(!isWasmInitialized) {
47990 throw new Error("initializeWasm() must be awaited first!");
47992 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
47993 // debug statements here
47995 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
47997 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
47998 if(!isWasmInitialized) {
47999 throw new Error("initializeWasm() must be awaited first!");
48001 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
48002 return nativeResponseValue;
48004 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
48006 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
48007 if(!isWasmInitialized) {
48008 throw new Error("initializeWasm() must be awaited first!");
48010 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
48011 // debug statements here
48013 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48015 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
48016 if(!isWasmInitialized) {
48017 throw new Error("initializeWasm() must be awaited first!");
48019 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
48020 return nativeResponseValue;
48022 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
48024 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
48025 if(!isWasmInitialized) {
48026 throw new Error("initializeWasm() must be awaited first!");
48028 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
48029 // debug statements here
48031 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
48033 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
48034 if(!isWasmInitialized) {
48035 throw new Error("initializeWasm() must be awaited first!");
48037 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
48038 return nativeResponseValue;
48040 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
48042 export function InMemorySigner_clone(orig: bigint): bigint {
48043 if(!isWasmInitialized) {
48044 throw new Error("initializeWasm() must be awaited first!");
48046 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
48047 return nativeResponseValue;
48049 // 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);
48051 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 {
48052 if(!isWasmInitialized) {
48053 throw new Error("initializeWasm() must be awaited first!");
48055 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);
48056 return nativeResponseValue;
48058 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48060 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
48061 if(!isWasmInitialized) {
48062 throw new Error("initializeWasm() must be awaited first!");
48064 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
48065 return nativeResponseValue;
48067 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48069 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): bigint {
48070 if(!isWasmInitialized) {
48071 throw new Error("initializeWasm() must be awaited first!");
48073 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
48074 return nativeResponseValue;
48076 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48078 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): bigint {
48079 if(!isWasmInitialized) {
48080 throw new Error("initializeWasm() must be awaited first!");
48082 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
48083 return nativeResponseValue;
48085 // MUST_USE_RES struct LDKCOption_boolZ InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48087 export function InMemorySigner_is_outbound(this_arg: bigint): bigint {
48088 if(!isWasmInitialized) {
48089 throw new Error("initializeWasm() must be awaited first!");
48091 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
48092 return nativeResponseValue;
48094 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48096 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
48097 if(!isWasmInitialized) {
48098 throw new Error("initializeWasm() must be awaited first!");
48100 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
48101 return nativeResponseValue;
48103 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48105 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
48106 if(!isWasmInitialized) {
48107 throw new Error("initializeWasm() must be awaited first!");
48109 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
48110 return nativeResponseValue;
48112 // MUST_USE_RES struct LDKChannelTypeFeatures InMemorySigner_channel_type_features(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48114 export function InMemorySigner_channel_type_features(this_arg: bigint): bigint {
48115 if(!isWasmInitialized) {
48116 throw new Error("initializeWasm() must be awaited first!");
48118 const nativeResponseValue = wasm.TS_InMemorySigner_channel_type_features(this_arg);
48119 return nativeResponseValue;
48121 // 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);
48123 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
48124 if(!isWasmInitialized) {
48125 throw new Error("initializeWasm() must be awaited first!");
48127 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
48128 return nativeResponseValue;
48130 // 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);
48132 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
48133 if(!isWasmInitialized) {
48134 throw new Error("initializeWasm() must be awaited first!");
48136 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
48137 return nativeResponseValue;
48139 // struct LDKEntropySource InMemorySigner_as_EntropySource(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48141 export function InMemorySigner_as_EntropySource(this_arg: bigint): bigint {
48142 if(!isWasmInitialized) {
48143 throw new Error("initializeWasm() must be awaited first!");
48145 const nativeResponseValue = wasm.TS_InMemorySigner_as_EntropySource(this_arg);
48146 return nativeResponseValue;
48148 // struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48150 export function InMemorySigner_as_ChannelSigner(this_arg: bigint): bigint {
48151 if(!isWasmInitialized) {
48152 throw new Error("initializeWasm() must be awaited first!");
48154 const nativeResponseValue = wasm.TS_InMemorySigner_as_ChannelSigner(this_arg);
48155 return nativeResponseValue;
48157 // struct LDKEcdsaChannelSigner InMemorySigner_as_EcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48159 export function InMemorySigner_as_EcdsaChannelSigner(this_arg: bigint): bigint {
48160 if(!isWasmInitialized) {
48161 throw new Error("initializeWasm() must be awaited first!");
48163 const nativeResponseValue = wasm.TS_InMemorySigner_as_EcdsaChannelSigner(this_arg);
48164 return nativeResponseValue;
48166 // struct LDKWriteableEcdsaChannelSigner InMemorySigner_as_WriteableEcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48168 export function InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg: bigint): bigint {
48169 if(!isWasmInitialized) {
48170 throw new Error("initializeWasm() must be awaited first!");
48172 const nativeResponseValue = wasm.TS_InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg);
48173 return nativeResponseValue;
48175 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
48177 export function InMemorySigner_write(obj: bigint): number {
48178 if(!isWasmInitialized) {
48179 throw new Error("initializeWasm() must be awaited first!");
48181 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
48182 return nativeResponseValue;
48184 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKEntropySource arg);
48186 export function InMemorySigner_read(ser: number, arg: bigint): bigint {
48187 if(!isWasmInitialized) {
48188 throw new Error("initializeWasm() must be awaited first!");
48190 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
48191 return nativeResponseValue;
48193 // void KeysManager_free(struct LDKKeysManager this_obj);
48195 export function KeysManager_free(this_obj: bigint): void {
48196 if(!isWasmInitialized) {
48197 throw new Error("initializeWasm() must be awaited first!");
48199 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
48200 // debug statements here
48202 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
48204 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
48205 if(!isWasmInitialized) {
48206 throw new Error("initializeWasm() must be awaited first!");
48208 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
48209 return nativeResponseValue;
48211 // MUST_USE_RES struct LDKSecretKey KeysManager_get_node_secret_key(const struct LDKKeysManager *NONNULL_PTR this_arg);
48213 export function KeysManager_get_node_secret_key(this_arg: bigint): number {
48214 if(!isWasmInitialized) {
48215 throw new Error("initializeWasm() must be awaited first!");
48217 const nativeResponseValue = wasm.TS_KeysManager_get_node_secret_key(this_arg);
48218 return nativeResponseValue;
48220 // 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]);
48222 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
48223 if(!isWasmInitialized) {
48224 throw new Error("initializeWasm() must be awaited first!");
48226 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
48227 return nativeResponseValue;
48229 // MUST_USE_RES struct LDKCResult_CVec_u8ZNoneZ KeysManager_sign_spendable_outputs_psbt(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_u8Z psbt);
48231 export function KeysManager_sign_spendable_outputs_psbt(this_arg: bigint, descriptors: number, psbt: number): bigint {
48232 if(!isWasmInitialized) {
48233 throw new Error("initializeWasm() must be awaited first!");
48235 const nativeResponseValue = wasm.TS_KeysManager_sign_spendable_outputs_psbt(this_arg, descriptors, psbt);
48236 return nativeResponseValue;
48238 // 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_u32Z locktime);
48240 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 {
48241 if(!isWasmInitialized) {
48242 throw new Error("initializeWasm() must be awaited first!");
48244 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
48245 return nativeResponseValue;
48247 // struct LDKEntropySource KeysManager_as_EntropySource(const struct LDKKeysManager *NONNULL_PTR this_arg);
48249 export function KeysManager_as_EntropySource(this_arg: bigint): bigint {
48250 if(!isWasmInitialized) {
48251 throw new Error("initializeWasm() must be awaited first!");
48253 const nativeResponseValue = wasm.TS_KeysManager_as_EntropySource(this_arg);
48254 return nativeResponseValue;
48256 // struct LDKNodeSigner KeysManager_as_NodeSigner(const struct LDKKeysManager *NONNULL_PTR this_arg);
48258 export function KeysManager_as_NodeSigner(this_arg: bigint): bigint {
48259 if(!isWasmInitialized) {
48260 throw new Error("initializeWasm() must be awaited first!");
48262 const nativeResponseValue = wasm.TS_KeysManager_as_NodeSigner(this_arg);
48263 return nativeResponseValue;
48265 // struct LDKSignerProvider KeysManager_as_SignerProvider(const struct LDKKeysManager *NONNULL_PTR this_arg);
48267 export function KeysManager_as_SignerProvider(this_arg: bigint): bigint {
48268 if(!isWasmInitialized) {
48269 throw new Error("initializeWasm() must be awaited first!");
48271 const nativeResponseValue = wasm.TS_KeysManager_as_SignerProvider(this_arg);
48272 return nativeResponseValue;
48274 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
48276 export function PhantomKeysManager_free(this_obj: bigint): void {
48277 if(!isWasmInitialized) {
48278 throw new Error("initializeWasm() must be awaited first!");
48280 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
48281 // debug statements here
48283 // struct LDKEntropySource PhantomKeysManager_as_EntropySource(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
48285 export function PhantomKeysManager_as_EntropySource(this_arg: bigint): bigint {
48286 if(!isWasmInitialized) {
48287 throw new Error("initializeWasm() must be awaited first!");
48289 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_EntropySource(this_arg);
48290 return nativeResponseValue;
48292 // struct LDKNodeSigner PhantomKeysManager_as_NodeSigner(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
48294 export function PhantomKeysManager_as_NodeSigner(this_arg: bigint): bigint {
48295 if(!isWasmInitialized) {
48296 throw new Error("initializeWasm() must be awaited first!");
48298 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_NodeSigner(this_arg);
48299 return nativeResponseValue;
48301 // struct LDKSignerProvider PhantomKeysManager_as_SignerProvider(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
48303 export function PhantomKeysManager_as_SignerProvider(this_arg: bigint): bigint {
48304 if(!isWasmInitialized) {
48305 throw new Error("initializeWasm() must be awaited first!");
48307 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_SignerProvider(this_arg);
48308 return nativeResponseValue;
48310 // 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]);
48312 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
48313 if(!isWasmInitialized) {
48314 throw new Error("initializeWasm() must be awaited first!");
48316 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
48317 return nativeResponseValue;
48319 // 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_u32Z locktime);
48321 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 {
48322 if(!isWasmInitialized) {
48323 throw new Error("initializeWasm() must be awaited first!");
48325 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
48326 return nativeResponseValue;
48328 // 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]);
48330 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
48331 if(!isWasmInitialized) {
48332 throw new Error("initializeWasm() must be awaited first!");
48334 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
48335 return nativeResponseValue;
48337 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
48339 export function PhantomKeysManager_get_node_secret_key(this_arg: bigint): number {
48340 if(!isWasmInitialized) {
48341 throw new Error("initializeWasm() must be awaited first!");
48343 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_node_secret_key(this_arg);
48344 return nativeResponseValue;
48346 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_phantom_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
48348 export function PhantomKeysManager_get_phantom_node_secret_key(this_arg: bigint): number {
48349 if(!isWasmInitialized) {
48350 throw new Error("initializeWasm() must be awaited first!");
48352 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_phantom_node_secret_key(this_arg);
48353 return nativeResponseValue;
48355 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
48357 export function OnionMessenger_free(this_obj: bigint): void {
48358 if(!isWasmInitialized) {
48359 throw new Error("initializeWasm() must be awaited first!");
48361 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
48362 // debug statements here
48364 // void MessageRouter_free(struct LDKMessageRouter this_ptr);
48366 export function MessageRouter_free(this_ptr: bigint): void {
48367 if(!isWasmInitialized) {
48368 throw new Error("initializeWasm() must be awaited first!");
48370 const nativeResponseValue = wasm.TS_MessageRouter_free(this_ptr);
48371 // debug statements here
48373 // void DefaultMessageRouter_free(struct LDKDefaultMessageRouter this_obj);
48375 export function DefaultMessageRouter_free(this_obj: bigint): void {
48376 if(!isWasmInitialized) {
48377 throw new Error("initializeWasm() must be awaited first!");
48379 const nativeResponseValue = wasm.TS_DefaultMessageRouter_free(this_obj);
48380 // debug statements here
48382 // MUST_USE_RES struct LDKDefaultMessageRouter DefaultMessageRouter_new(void);
48384 export function DefaultMessageRouter_new(): bigint {
48385 if(!isWasmInitialized) {
48386 throw new Error("initializeWasm() must be awaited first!");
48388 const nativeResponseValue = wasm.TS_DefaultMessageRouter_new();
48389 return nativeResponseValue;
48391 // struct LDKMessageRouter DefaultMessageRouter_as_MessageRouter(const struct LDKDefaultMessageRouter *NONNULL_PTR this_arg);
48393 export function DefaultMessageRouter_as_MessageRouter(this_arg: bigint): bigint {
48394 if(!isWasmInitialized) {
48395 throw new Error("initializeWasm() must be awaited first!");
48397 const nativeResponseValue = wasm.TS_DefaultMessageRouter_as_MessageRouter(this_arg);
48398 return nativeResponseValue;
48400 // void OnionMessagePath_free(struct LDKOnionMessagePath this_obj);
48402 export function OnionMessagePath_free(this_obj: bigint): void {
48403 if(!isWasmInitialized) {
48404 throw new Error("initializeWasm() must be awaited first!");
48406 const nativeResponseValue = wasm.TS_OnionMessagePath_free(this_obj);
48407 // debug statements here
48409 // struct LDKCVec_PublicKeyZ OnionMessagePath_get_intermediate_nodes(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
48411 export function OnionMessagePath_get_intermediate_nodes(this_ptr: bigint): number {
48412 if(!isWasmInitialized) {
48413 throw new Error("initializeWasm() must be awaited first!");
48415 const nativeResponseValue = wasm.TS_OnionMessagePath_get_intermediate_nodes(this_ptr);
48416 return nativeResponseValue;
48418 // void OnionMessagePath_set_intermediate_nodes(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCVec_PublicKeyZ val);
48420 export function OnionMessagePath_set_intermediate_nodes(this_ptr: bigint, val: number): void {
48421 if(!isWasmInitialized) {
48422 throw new Error("initializeWasm() must be awaited first!");
48424 const nativeResponseValue = wasm.TS_OnionMessagePath_set_intermediate_nodes(this_ptr, val);
48425 // debug statements here
48427 // struct LDKDestination OnionMessagePath_get_destination(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
48429 export function OnionMessagePath_get_destination(this_ptr: bigint): bigint {
48430 if(!isWasmInitialized) {
48431 throw new Error("initializeWasm() must be awaited first!");
48433 const nativeResponseValue = wasm.TS_OnionMessagePath_get_destination(this_ptr);
48434 return nativeResponseValue;
48436 // void OnionMessagePath_set_destination(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKDestination val);
48438 export function OnionMessagePath_set_destination(this_ptr: bigint, val: bigint): void {
48439 if(!isWasmInitialized) {
48440 throw new Error("initializeWasm() must be awaited first!");
48442 const nativeResponseValue = wasm.TS_OnionMessagePath_set_destination(this_ptr, val);
48443 // debug statements here
48445 // MUST_USE_RES struct LDKOnionMessagePath OnionMessagePath_new(struct LDKCVec_PublicKeyZ intermediate_nodes_arg, struct LDKDestination destination_arg);
48447 export function OnionMessagePath_new(intermediate_nodes_arg: number, destination_arg: bigint): bigint {
48448 if(!isWasmInitialized) {
48449 throw new Error("initializeWasm() must be awaited first!");
48451 const nativeResponseValue = wasm.TS_OnionMessagePath_new(intermediate_nodes_arg, destination_arg);
48452 return nativeResponseValue;
48454 // uint64_t OnionMessagePath_clone_ptr(LDKOnionMessagePath *NONNULL_PTR arg);
48456 export function OnionMessagePath_clone_ptr(arg: bigint): bigint {
48457 if(!isWasmInitialized) {
48458 throw new Error("initializeWasm() must be awaited first!");
48460 const nativeResponseValue = wasm.TS_OnionMessagePath_clone_ptr(arg);
48461 return nativeResponseValue;
48463 // struct LDKOnionMessagePath OnionMessagePath_clone(const struct LDKOnionMessagePath *NONNULL_PTR orig);
48465 export function OnionMessagePath_clone(orig: bigint): bigint {
48466 if(!isWasmInitialized) {
48467 throw new Error("initializeWasm() must be awaited first!");
48469 const nativeResponseValue = wasm.TS_OnionMessagePath_clone(orig);
48470 return nativeResponseValue;
48472 // void Destination_free(struct LDKDestination this_ptr);
48474 export function Destination_free(this_ptr: bigint): void {
48475 if(!isWasmInitialized) {
48476 throw new Error("initializeWasm() must be awaited first!");
48478 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
48479 // debug statements here
48481 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
48483 export function Destination_clone_ptr(arg: bigint): bigint {
48484 if(!isWasmInitialized) {
48485 throw new Error("initializeWasm() must be awaited first!");
48487 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
48488 return nativeResponseValue;
48490 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
48492 export function Destination_clone(orig: bigint): bigint {
48493 if(!isWasmInitialized) {
48494 throw new Error("initializeWasm() must be awaited first!");
48496 const nativeResponseValue = wasm.TS_Destination_clone(orig);
48497 return nativeResponseValue;
48499 // struct LDKDestination Destination_node(struct LDKPublicKey a);
48501 export function Destination_node(a: number): bigint {
48502 if(!isWasmInitialized) {
48503 throw new Error("initializeWasm() must be awaited first!");
48505 const nativeResponseValue = wasm.TS_Destination_node(a);
48506 return nativeResponseValue;
48508 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
48510 export function Destination_blinded_path(a: bigint): bigint {
48511 if(!isWasmInitialized) {
48512 throw new Error("initializeWasm() must be awaited first!");
48514 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
48515 return nativeResponseValue;
48517 // void SendError_free(struct LDKSendError this_ptr);
48519 export function SendError_free(this_ptr: bigint): void {
48520 if(!isWasmInitialized) {
48521 throw new Error("initializeWasm() must be awaited first!");
48523 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
48524 // debug statements here
48526 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
48528 export function SendError_clone_ptr(arg: bigint): bigint {
48529 if(!isWasmInitialized) {
48530 throw new Error("initializeWasm() must be awaited first!");
48532 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
48533 return nativeResponseValue;
48535 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
48537 export function SendError_clone(orig: bigint): bigint {
48538 if(!isWasmInitialized) {
48539 throw new Error("initializeWasm() must be awaited first!");
48541 const nativeResponseValue = wasm.TS_SendError_clone(orig);
48542 return nativeResponseValue;
48544 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
48546 export function SendError_secp256k1(a: Secp256k1Error): bigint {
48547 if(!isWasmInitialized) {
48548 throw new Error("initializeWasm() must be awaited first!");
48550 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
48551 return nativeResponseValue;
48553 // struct LDKSendError SendError_too_big_packet(void);
48555 export function SendError_too_big_packet(): bigint {
48556 if(!isWasmInitialized) {
48557 throw new Error("initializeWasm() must be awaited first!");
48559 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
48560 return nativeResponseValue;
48562 // struct LDKSendError SendError_too_few_blinded_hops(void);
48564 export function SendError_too_few_blinded_hops(): bigint {
48565 if(!isWasmInitialized) {
48566 throw new Error("initializeWasm() must be awaited first!");
48568 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
48569 return nativeResponseValue;
48571 // struct LDKSendError SendError_invalid_first_hop(void);
48573 export function SendError_invalid_first_hop(): bigint {
48574 if(!isWasmInitialized) {
48575 throw new Error("initializeWasm() must be awaited first!");
48577 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
48578 return nativeResponseValue;
48580 // struct LDKSendError SendError_invalid_message(void);
48582 export function SendError_invalid_message(): bigint {
48583 if(!isWasmInitialized) {
48584 throw new Error("initializeWasm() must be awaited first!");
48586 const nativeResponseValue = wasm.TS_SendError_invalid_message();
48587 return nativeResponseValue;
48589 // struct LDKSendError SendError_buffer_full(void);
48591 export function SendError_buffer_full(): bigint {
48592 if(!isWasmInitialized) {
48593 throw new Error("initializeWasm() must be awaited first!");
48595 const nativeResponseValue = wasm.TS_SendError_buffer_full();
48596 return nativeResponseValue;
48598 // struct LDKSendError SendError_get_node_id_failed(void);
48600 export function SendError_get_node_id_failed(): bigint {
48601 if(!isWasmInitialized) {
48602 throw new Error("initializeWasm() must be awaited first!");
48604 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
48605 return nativeResponseValue;
48607 // struct LDKSendError SendError_blinded_path_advance_failed(void);
48609 export function SendError_blinded_path_advance_failed(): bigint {
48610 if(!isWasmInitialized) {
48611 throw new Error("initializeWasm() must be awaited first!");
48613 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
48614 return nativeResponseValue;
48616 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
48618 export function SendError_eq(a: bigint, b: bigint): boolean {
48619 if(!isWasmInitialized) {
48620 throw new Error("initializeWasm() must be awaited first!");
48622 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
48623 return nativeResponseValue;
48625 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
48627 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
48628 if(!isWasmInitialized) {
48629 throw new Error("initializeWasm() must be awaited first!");
48631 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
48632 // debug statements here
48634 // struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ create_onion_message(const struct LDKEntropySource *NONNULL_PTR entropy_source, const struct LDKNodeSigner *NONNULL_PTR node_signer, struct LDKOnionMessagePath path, struct LDKOnionMessageContents message, struct LDKBlindedPath reply_path);
48636 export function create_onion_message(entropy_source: bigint, node_signer: bigint, path: bigint, message: bigint, reply_path: bigint): bigint {
48637 if(!isWasmInitialized) {
48638 throw new Error("initializeWasm() must be awaited first!");
48640 const nativeResponseValue = wasm.TS_create_onion_message(entropy_source, node_signer, path, message, reply_path);
48641 return nativeResponseValue;
48643 // 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);
48645 export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, message_router: bigint, offers_handler: bigint, custom_handler: bigint): bigint {
48646 if(!isWasmInitialized) {
48647 throw new Error("initializeWasm() must be awaited first!");
48649 const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, message_router, offers_handler, custom_handler);
48650 return nativeResponseValue;
48652 // 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);
48654 export function OnionMessenger_send_onion_message(this_arg: bigint, path: bigint, message: bigint, reply_path: bigint): bigint {
48655 if(!isWasmInitialized) {
48656 throw new Error("initializeWasm() must be awaited first!");
48658 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, path, message, reply_path);
48659 return nativeResponseValue;
48661 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
48663 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
48664 if(!isWasmInitialized) {
48665 throw new Error("initializeWasm() must be awaited first!");
48667 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
48668 return nativeResponseValue;
48670 // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
48672 export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
48673 if(!isWasmInitialized) {
48674 throw new Error("initializeWasm() must be awaited first!");
48676 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
48677 return nativeResponseValue;
48679 // void OffersMessageHandler_free(struct LDKOffersMessageHandler this_ptr);
48681 export function OffersMessageHandler_free(this_ptr: bigint): void {
48682 if(!isWasmInitialized) {
48683 throw new Error("initializeWasm() must be awaited first!");
48685 const nativeResponseValue = wasm.TS_OffersMessageHandler_free(this_ptr);
48686 // debug statements here
48688 // void OffersMessage_free(struct LDKOffersMessage this_ptr);
48690 export function OffersMessage_free(this_ptr: bigint): void {
48691 if(!isWasmInitialized) {
48692 throw new Error("initializeWasm() must be awaited first!");
48694 const nativeResponseValue = wasm.TS_OffersMessage_free(this_ptr);
48695 // debug statements here
48697 // uint64_t OffersMessage_clone_ptr(LDKOffersMessage *NONNULL_PTR arg);
48699 export function OffersMessage_clone_ptr(arg: bigint): bigint {
48700 if(!isWasmInitialized) {
48701 throw new Error("initializeWasm() must be awaited first!");
48703 const nativeResponseValue = wasm.TS_OffersMessage_clone_ptr(arg);
48704 return nativeResponseValue;
48706 // struct LDKOffersMessage OffersMessage_clone(const struct LDKOffersMessage *NONNULL_PTR orig);
48708 export function OffersMessage_clone(orig: bigint): bigint {
48709 if(!isWasmInitialized) {
48710 throw new Error("initializeWasm() must be awaited first!");
48712 const nativeResponseValue = wasm.TS_OffersMessage_clone(orig);
48713 return nativeResponseValue;
48715 // struct LDKOffersMessage OffersMessage_invoice_request(struct LDKInvoiceRequest a);
48717 export function OffersMessage_invoice_request(a: bigint): bigint {
48718 if(!isWasmInitialized) {
48719 throw new Error("initializeWasm() must be awaited first!");
48721 const nativeResponseValue = wasm.TS_OffersMessage_invoice_request(a);
48722 return nativeResponseValue;
48724 // struct LDKOffersMessage OffersMessage_invoice(struct LDKBolt12Invoice a);
48726 export function OffersMessage_invoice(a: bigint): bigint {
48727 if(!isWasmInitialized) {
48728 throw new Error("initializeWasm() must be awaited first!");
48730 const nativeResponseValue = wasm.TS_OffersMessage_invoice(a);
48731 return nativeResponseValue;
48733 // struct LDKOffersMessage OffersMessage_invoice_error(struct LDKInvoiceError a);
48735 export function OffersMessage_invoice_error(a: bigint): bigint {
48736 if(!isWasmInitialized) {
48737 throw new Error("initializeWasm() must be awaited first!");
48739 const nativeResponseValue = wasm.TS_OffersMessage_invoice_error(a);
48740 return nativeResponseValue;
48742 // MUST_USE_RES bool OffersMessage_is_known_type(uint64_t tlv_type);
48744 export function OffersMessage_is_known_type(tlv_type: bigint): boolean {
48745 if(!isWasmInitialized) {
48746 throw new Error("initializeWasm() must be awaited first!");
48748 const nativeResponseValue = wasm.TS_OffersMessage_is_known_type(tlv_type);
48749 return nativeResponseValue;
48751 // MUST_USE_RES uint64_t OffersMessage_tlv_type(const struct LDKOffersMessage *NONNULL_PTR this_arg);
48753 export function OffersMessage_tlv_type(this_arg: bigint): bigint {
48754 if(!isWasmInitialized) {
48755 throw new Error("initializeWasm() must be awaited first!");
48757 const nativeResponseValue = wasm.TS_OffersMessage_tlv_type(this_arg);
48758 return nativeResponseValue;
48760 // struct LDKCVec_u8Z OffersMessage_write(const struct LDKOffersMessage *NONNULL_PTR obj);
48762 export function OffersMessage_write(obj: bigint): number {
48763 if(!isWasmInitialized) {
48764 throw new Error("initializeWasm() must be awaited first!");
48766 const nativeResponseValue = wasm.TS_OffersMessage_write(obj);
48767 return nativeResponseValue;
48769 // struct LDKCResult_OffersMessageDecodeErrorZ OffersMessage_read(struct LDKu8slice ser, uint64_t arg_a, const struct LDKLogger *NONNULL_PTR arg_b);
48771 export function OffersMessage_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
48772 if(!isWasmInitialized) {
48773 throw new Error("initializeWasm() must be awaited first!");
48775 const nativeResponseValue = wasm.TS_OffersMessage_read(ser, arg_a, arg_b);
48776 return nativeResponseValue;
48778 // void Packet_free(struct LDKPacket this_obj);
48780 export function Packet_free(this_obj: bigint): void {
48781 if(!isWasmInitialized) {
48782 throw new Error("initializeWasm() must be awaited first!");
48784 const nativeResponseValue = wasm.TS_Packet_free(this_obj);
48785 // debug statements here
48787 // uint8_t Packet_get_version(const struct LDKPacket *NONNULL_PTR this_ptr);
48789 export function Packet_get_version(this_ptr: bigint): number {
48790 if(!isWasmInitialized) {
48791 throw new Error("initializeWasm() must be awaited first!");
48793 const nativeResponseValue = wasm.TS_Packet_get_version(this_ptr);
48794 return nativeResponseValue;
48796 // void Packet_set_version(struct LDKPacket *NONNULL_PTR this_ptr, uint8_t val);
48798 export function Packet_set_version(this_ptr: bigint, val: number): void {
48799 if(!isWasmInitialized) {
48800 throw new Error("initializeWasm() must be awaited first!");
48802 const nativeResponseValue = wasm.TS_Packet_set_version(this_ptr, val);
48803 // debug statements here
48805 // struct LDKPublicKey Packet_get_public_key(const struct LDKPacket *NONNULL_PTR this_ptr);
48807 export function Packet_get_public_key(this_ptr: bigint): number {
48808 if(!isWasmInitialized) {
48809 throw new Error("initializeWasm() must be awaited first!");
48811 const nativeResponseValue = wasm.TS_Packet_get_public_key(this_ptr);
48812 return nativeResponseValue;
48814 // void Packet_set_public_key(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKPublicKey val);
48816 export function Packet_set_public_key(this_ptr: bigint, val: number): void {
48817 if(!isWasmInitialized) {
48818 throw new Error("initializeWasm() must be awaited first!");
48820 const nativeResponseValue = wasm.TS_Packet_set_public_key(this_ptr, val);
48821 // debug statements here
48823 // struct LDKCVec_u8Z Packet_get_hop_data(const struct LDKPacket *NONNULL_PTR this_ptr);
48825 export function Packet_get_hop_data(this_ptr: bigint): number {
48826 if(!isWasmInitialized) {
48827 throw new Error("initializeWasm() must be awaited first!");
48829 const nativeResponseValue = wasm.TS_Packet_get_hop_data(this_ptr);
48830 return nativeResponseValue;
48832 // void Packet_set_hop_data(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
48834 export function Packet_set_hop_data(this_ptr: bigint, val: number): void {
48835 if(!isWasmInitialized) {
48836 throw new Error("initializeWasm() must be awaited first!");
48838 const nativeResponseValue = wasm.TS_Packet_set_hop_data(this_ptr, val);
48839 // debug statements here
48841 // const uint8_t (*Packet_get_hmac(const struct LDKPacket *NONNULL_PTR this_ptr))[32];
48843 export function Packet_get_hmac(this_ptr: bigint): number {
48844 if(!isWasmInitialized) {
48845 throw new Error("initializeWasm() must be awaited first!");
48847 const nativeResponseValue = wasm.TS_Packet_get_hmac(this_ptr);
48848 return nativeResponseValue;
48850 // void Packet_set_hmac(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
48852 export function Packet_set_hmac(this_ptr: bigint, val: number): void {
48853 if(!isWasmInitialized) {
48854 throw new Error("initializeWasm() must be awaited first!");
48856 const nativeResponseValue = wasm.TS_Packet_set_hmac(this_ptr, val);
48857 // debug statements here
48859 // MUST_USE_RES struct LDKPacket Packet_new(uint8_t version_arg, struct LDKPublicKey public_key_arg, struct LDKCVec_u8Z hop_data_arg, struct LDKThirtyTwoBytes hmac_arg);
48861 export function Packet_new(version_arg: number, public_key_arg: number, hop_data_arg: number, hmac_arg: number): bigint {
48862 if(!isWasmInitialized) {
48863 throw new Error("initializeWasm() must be awaited first!");
48865 const nativeResponseValue = wasm.TS_Packet_new(version_arg, public_key_arg, hop_data_arg, hmac_arg);
48866 return nativeResponseValue;
48868 // uint64_t Packet_clone_ptr(LDKPacket *NONNULL_PTR arg);
48870 export function Packet_clone_ptr(arg: bigint): bigint {
48871 if(!isWasmInitialized) {
48872 throw new Error("initializeWasm() must be awaited first!");
48874 const nativeResponseValue = wasm.TS_Packet_clone_ptr(arg);
48875 return nativeResponseValue;
48877 // struct LDKPacket Packet_clone(const struct LDKPacket *NONNULL_PTR orig);
48879 export function Packet_clone(orig: bigint): bigint {
48880 if(!isWasmInitialized) {
48881 throw new Error("initializeWasm() must be awaited first!");
48883 const nativeResponseValue = wasm.TS_Packet_clone(orig);
48884 return nativeResponseValue;
48886 // bool Packet_eq(const struct LDKPacket *NONNULL_PTR a, const struct LDKPacket *NONNULL_PTR b);
48888 export function Packet_eq(a: bigint, b: bigint): boolean {
48889 if(!isWasmInitialized) {
48890 throw new Error("initializeWasm() must be awaited first!");
48892 const nativeResponseValue = wasm.TS_Packet_eq(a, b);
48893 return nativeResponseValue;
48895 // struct LDKCVec_u8Z Packet_write(const struct LDKPacket *NONNULL_PTR obj);
48897 export function Packet_write(obj: bigint): number {
48898 if(!isWasmInitialized) {
48899 throw new Error("initializeWasm() must be awaited first!");
48901 const nativeResponseValue = wasm.TS_Packet_write(obj);
48902 return nativeResponseValue;
48904 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
48906 export function OnionMessageContents_free(this_ptr: bigint): void {
48907 if(!isWasmInitialized) {
48908 throw new Error("initializeWasm() must be awaited first!");
48910 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
48911 // debug statements here
48913 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
48915 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
48916 if(!isWasmInitialized) {
48917 throw new Error("initializeWasm() must be awaited first!");
48919 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
48920 return nativeResponseValue;
48922 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
48924 export function OnionMessageContents_clone(orig: bigint): bigint {
48925 if(!isWasmInitialized) {
48926 throw new Error("initializeWasm() must be awaited first!");
48928 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
48929 return nativeResponseValue;
48931 // struct LDKOnionMessageContents OnionMessageContents_offers(struct LDKOffersMessage a);
48933 export function OnionMessageContents_offers(a: bigint): bigint {
48934 if(!isWasmInitialized) {
48935 throw new Error("initializeWasm() must be awaited first!");
48937 const nativeResponseValue = wasm.TS_OnionMessageContents_offers(a);
48938 return nativeResponseValue;
48940 // struct LDKOnionMessageContents OnionMessageContents_custom(struct LDKCustomOnionMessageContents a);
48942 export function OnionMessageContents_custom(a: bigint): bigint {
48943 if(!isWasmInitialized) {
48944 throw new Error("initializeWasm() must be awaited first!");
48946 const nativeResponseValue = wasm.TS_OnionMessageContents_custom(a);
48947 return nativeResponseValue;
48949 // uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg);
48951 export function CustomOnionMessageContents_clone_ptr(arg: bigint): bigint {
48952 if(!isWasmInitialized) {
48953 throw new Error("initializeWasm() must be awaited first!");
48955 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone_ptr(arg);
48956 return nativeResponseValue;
48958 // struct LDKCustomOnionMessageContents CustomOnionMessageContents_clone(const struct LDKCustomOnionMessageContents *NONNULL_PTR orig);
48960 export function CustomOnionMessageContents_clone(orig: bigint): bigint {
48961 if(!isWasmInitialized) {
48962 throw new Error("initializeWasm() must be awaited first!");
48964 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_clone(orig);
48965 return nativeResponseValue;
48967 // void CustomOnionMessageContents_free(struct LDKCustomOnionMessageContents this_ptr);
48969 export function CustomOnionMessageContents_free(this_ptr: bigint): void {
48970 if(!isWasmInitialized) {
48971 throw new Error("initializeWasm() must be awaited first!");
48973 const nativeResponseValue = wasm.TS_CustomOnionMessageContents_free(this_ptr);
48974 // debug statements here
48976 // void BlindedPath_free(struct LDKBlindedPath this_obj);
48978 export function BlindedPath_free(this_obj: bigint): void {
48979 if(!isWasmInitialized) {
48980 throw new Error("initializeWasm() must be awaited first!");
48982 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
48983 // debug statements here
48985 // struct LDKPublicKey BlindedPath_get_introduction_node_id(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
48987 export function BlindedPath_get_introduction_node_id(this_ptr: bigint): number {
48988 if(!isWasmInitialized) {
48989 throw new Error("initializeWasm() must be awaited first!");
48991 const nativeResponseValue = wasm.TS_BlindedPath_get_introduction_node_id(this_ptr);
48992 return nativeResponseValue;
48994 // void BlindedPath_set_introduction_node_id(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
48996 export function BlindedPath_set_introduction_node_id(this_ptr: bigint, val: number): void {
48997 if(!isWasmInitialized) {
48998 throw new Error("initializeWasm() must be awaited first!");
49000 const nativeResponseValue = wasm.TS_BlindedPath_set_introduction_node_id(this_ptr, val);
49001 // debug statements here
49003 // struct LDKPublicKey BlindedPath_get_blinding_point(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
49005 export function BlindedPath_get_blinding_point(this_ptr: bigint): number {
49006 if(!isWasmInitialized) {
49007 throw new Error("initializeWasm() must be awaited first!");
49009 const nativeResponseValue = wasm.TS_BlindedPath_get_blinding_point(this_ptr);
49010 return nativeResponseValue;
49012 // void BlindedPath_set_blinding_point(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
49014 export function BlindedPath_set_blinding_point(this_ptr: bigint, val: number): void {
49015 if(!isWasmInitialized) {
49016 throw new Error("initializeWasm() must be awaited first!");
49018 const nativeResponseValue = wasm.TS_BlindedPath_set_blinding_point(this_ptr, val);
49019 // debug statements here
49021 // struct LDKCVec_BlindedHopZ BlindedPath_get_blinded_hops(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
49023 export function BlindedPath_get_blinded_hops(this_ptr: bigint): number {
49024 if(!isWasmInitialized) {
49025 throw new Error("initializeWasm() must be awaited first!");
49027 const nativeResponseValue = wasm.TS_BlindedPath_get_blinded_hops(this_ptr);
49028 return nativeResponseValue;
49030 // void BlindedPath_set_blinded_hops(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
49032 export function BlindedPath_set_blinded_hops(this_ptr: bigint, val: number): void {
49033 if(!isWasmInitialized) {
49034 throw new Error("initializeWasm() must be awaited first!");
49036 const nativeResponseValue = wasm.TS_BlindedPath_set_blinded_hops(this_ptr, val);
49037 // debug statements here
49039 // MUST_USE_RES struct LDKBlindedPath BlindedPath_new(struct LDKPublicKey introduction_node_id_arg, struct LDKPublicKey blinding_point_arg, struct LDKCVec_BlindedHopZ blinded_hops_arg);
49041 export function BlindedPath_new(introduction_node_id_arg: number, blinding_point_arg: number, blinded_hops_arg: number): bigint {
49042 if(!isWasmInitialized) {
49043 throw new Error("initializeWasm() must be awaited first!");
49045 const nativeResponseValue = wasm.TS_BlindedPath_new(introduction_node_id_arg, blinding_point_arg, blinded_hops_arg);
49046 return nativeResponseValue;
49048 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
49050 export function BlindedPath_clone_ptr(arg: bigint): bigint {
49051 if(!isWasmInitialized) {
49052 throw new Error("initializeWasm() must be awaited first!");
49054 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
49055 return nativeResponseValue;
49057 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
49059 export function BlindedPath_clone(orig: bigint): bigint {
49060 if(!isWasmInitialized) {
49061 throw new Error("initializeWasm() must be awaited first!");
49063 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
49064 return nativeResponseValue;
49066 // uint64_t BlindedPath_hash(const struct LDKBlindedPath *NONNULL_PTR o);
49068 export function BlindedPath_hash(o: bigint): bigint {
49069 if(!isWasmInitialized) {
49070 throw new Error("initializeWasm() must be awaited first!");
49072 const nativeResponseValue = wasm.TS_BlindedPath_hash(o);
49073 return nativeResponseValue;
49075 // bool BlindedPath_eq(const struct LDKBlindedPath *NONNULL_PTR a, const struct LDKBlindedPath *NONNULL_PTR b);
49077 export function BlindedPath_eq(a: bigint, b: bigint): boolean {
49078 if(!isWasmInitialized) {
49079 throw new Error("initializeWasm() must be awaited first!");
49081 const nativeResponseValue = wasm.TS_BlindedPath_eq(a, b);
49082 return nativeResponseValue;
49084 // void BlindedHop_free(struct LDKBlindedHop this_obj);
49086 export function BlindedHop_free(this_obj: bigint): void {
49087 if(!isWasmInitialized) {
49088 throw new Error("initializeWasm() must be awaited first!");
49090 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
49091 // debug statements here
49093 // struct LDKPublicKey BlindedHop_get_blinded_node_id(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
49095 export function BlindedHop_get_blinded_node_id(this_ptr: bigint): number {
49096 if(!isWasmInitialized) {
49097 throw new Error("initializeWasm() must be awaited first!");
49099 const nativeResponseValue = wasm.TS_BlindedHop_get_blinded_node_id(this_ptr);
49100 return nativeResponseValue;
49102 // void BlindedHop_set_blinded_node_id(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
49104 export function BlindedHop_set_blinded_node_id(this_ptr: bigint, val: number): void {
49105 if(!isWasmInitialized) {
49106 throw new Error("initializeWasm() must be awaited first!");
49108 const nativeResponseValue = wasm.TS_BlindedHop_set_blinded_node_id(this_ptr, val);
49109 // debug statements here
49111 // struct LDKCVec_u8Z BlindedHop_get_encrypted_payload(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
49113 export function BlindedHop_get_encrypted_payload(this_ptr: bigint): number {
49114 if(!isWasmInitialized) {
49115 throw new Error("initializeWasm() must be awaited first!");
49117 const nativeResponseValue = wasm.TS_BlindedHop_get_encrypted_payload(this_ptr);
49118 return nativeResponseValue;
49120 // void BlindedHop_set_encrypted_payload(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
49122 export function BlindedHop_set_encrypted_payload(this_ptr: bigint, val: number): void {
49123 if(!isWasmInitialized) {
49124 throw new Error("initializeWasm() must be awaited first!");
49126 const nativeResponseValue = wasm.TS_BlindedHop_set_encrypted_payload(this_ptr, val);
49127 // debug statements here
49129 // MUST_USE_RES struct LDKBlindedHop BlindedHop_new(struct LDKPublicKey blinded_node_id_arg, struct LDKCVec_u8Z encrypted_payload_arg);
49131 export function BlindedHop_new(blinded_node_id_arg: number, encrypted_payload_arg: number): bigint {
49132 if(!isWasmInitialized) {
49133 throw new Error("initializeWasm() must be awaited first!");
49135 const nativeResponseValue = wasm.TS_BlindedHop_new(blinded_node_id_arg, encrypted_payload_arg);
49136 return nativeResponseValue;
49138 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
49140 export function BlindedHop_clone_ptr(arg: bigint): bigint {
49141 if(!isWasmInitialized) {
49142 throw new Error("initializeWasm() must be awaited first!");
49144 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
49145 return nativeResponseValue;
49147 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
49149 export function BlindedHop_clone(orig: bigint): bigint {
49150 if(!isWasmInitialized) {
49151 throw new Error("initializeWasm() must be awaited first!");
49153 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
49154 return nativeResponseValue;
49156 // uint64_t BlindedHop_hash(const struct LDKBlindedHop *NONNULL_PTR o);
49158 export function BlindedHop_hash(o: bigint): bigint {
49159 if(!isWasmInitialized) {
49160 throw new Error("initializeWasm() must be awaited first!");
49162 const nativeResponseValue = wasm.TS_BlindedHop_hash(o);
49163 return nativeResponseValue;
49165 // bool BlindedHop_eq(const struct LDKBlindedHop *NONNULL_PTR a, const struct LDKBlindedHop *NONNULL_PTR b);
49167 export function BlindedHop_eq(a: bigint, b: bigint): boolean {
49168 if(!isWasmInitialized) {
49169 throw new Error("initializeWasm() must be awaited first!");
49171 const nativeResponseValue = wasm.TS_BlindedHop_eq(a, b);
49172 return nativeResponseValue;
49174 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new_for_message(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
49176 export function BlindedPath_new_for_message(node_pks: number, entropy_source: bigint): bigint {
49177 if(!isWasmInitialized) {
49178 throw new Error("initializeWasm() must be awaited first!");
49180 const nativeResponseValue = wasm.TS_BlindedPath_new_for_message(node_pks, entropy_source);
49181 return nativeResponseValue;
49183 // MUST_USE_RES struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ BlindedPath_one_hop_for_payment(struct LDKPublicKey payee_node_id, struct LDKReceiveTlvs payee_tlvs, const struct LDKEntropySource *NONNULL_PTR entropy_source);
49185 export function BlindedPath_one_hop_for_payment(payee_node_id: number, payee_tlvs: bigint, entropy_source: bigint): bigint {
49186 if(!isWasmInitialized) {
49187 throw new Error("initializeWasm() must be awaited first!");
49189 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_payment(payee_node_id, payee_tlvs, entropy_source);
49190 return nativeResponseValue;
49192 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
49194 export function BlindedPath_write(obj: bigint): number {
49195 if(!isWasmInitialized) {
49196 throw new Error("initializeWasm() must be awaited first!");
49198 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
49199 return nativeResponseValue;
49201 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
49203 export function BlindedPath_read(ser: number): bigint {
49204 if(!isWasmInitialized) {
49205 throw new Error("initializeWasm() must be awaited first!");
49207 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
49208 return nativeResponseValue;
49210 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
49212 export function BlindedHop_write(obj: bigint): number {
49213 if(!isWasmInitialized) {
49214 throw new Error("initializeWasm() must be awaited first!");
49216 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
49217 return nativeResponseValue;
49219 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
49221 export function BlindedHop_read(ser: number): bigint {
49222 if(!isWasmInitialized) {
49223 throw new Error("initializeWasm() must be awaited first!");
49225 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
49226 return nativeResponseValue;
49228 // void ForwardNode_free(struct LDKForwardNode this_obj);
49230 export function ForwardNode_free(this_obj: bigint): void {
49231 if(!isWasmInitialized) {
49232 throw new Error("initializeWasm() must be awaited first!");
49234 const nativeResponseValue = wasm.TS_ForwardNode_free(this_obj);
49235 // debug statements here
49237 // struct LDKForwardTlvs ForwardNode_get_tlvs(const struct LDKForwardNode *NONNULL_PTR this_ptr);
49239 export function ForwardNode_get_tlvs(this_ptr: bigint): bigint {
49240 if(!isWasmInitialized) {
49241 throw new Error("initializeWasm() must be awaited first!");
49243 const nativeResponseValue = wasm.TS_ForwardNode_get_tlvs(this_ptr);
49244 return nativeResponseValue;
49246 // void ForwardNode_set_tlvs(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKForwardTlvs val);
49248 export function ForwardNode_set_tlvs(this_ptr: bigint, val: bigint): void {
49249 if(!isWasmInitialized) {
49250 throw new Error("initializeWasm() must be awaited first!");
49252 const nativeResponseValue = wasm.TS_ForwardNode_set_tlvs(this_ptr, val);
49253 // debug statements here
49255 // struct LDKPublicKey ForwardNode_get_node_id(const struct LDKForwardNode *NONNULL_PTR this_ptr);
49257 export function ForwardNode_get_node_id(this_ptr: bigint): number {
49258 if(!isWasmInitialized) {
49259 throw new Error("initializeWasm() must be awaited first!");
49261 const nativeResponseValue = wasm.TS_ForwardNode_get_node_id(this_ptr);
49262 return nativeResponseValue;
49264 // void ForwardNode_set_node_id(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKPublicKey val);
49266 export function ForwardNode_set_node_id(this_ptr: bigint, val: number): void {
49267 if(!isWasmInitialized) {
49268 throw new Error("initializeWasm() must be awaited first!");
49270 const nativeResponseValue = wasm.TS_ForwardNode_set_node_id(this_ptr, val);
49271 // debug statements here
49273 // uint64_t ForwardNode_get_htlc_maximum_msat(const struct LDKForwardNode *NONNULL_PTR this_ptr);
49275 export function ForwardNode_get_htlc_maximum_msat(this_ptr: bigint): bigint {
49276 if(!isWasmInitialized) {
49277 throw new Error("initializeWasm() must be awaited first!");
49279 const nativeResponseValue = wasm.TS_ForwardNode_get_htlc_maximum_msat(this_ptr);
49280 return nativeResponseValue;
49282 // void ForwardNode_set_htlc_maximum_msat(struct LDKForwardNode *NONNULL_PTR this_ptr, uint64_t val);
49284 export function ForwardNode_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
49285 if(!isWasmInitialized) {
49286 throw new Error("initializeWasm() must be awaited first!");
49288 const nativeResponseValue = wasm.TS_ForwardNode_set_htlc_maximum_msat(this_ptr, val);
49289 // debug statements here
49291 // MUST_USE_RES struct LDKForwardNode ForwardNode_new(struct LDKForwardTlvs tlvs_arg, struct LDKPublicKey node_id_arg, uint64_t htlc_maximum_msat_arg);
49293 export function ForwardNode_new(tlvs_arg: bigint, node_id_arg: number, htlc_maximum_msat_arg: bigint): bigint {
49294 if(!isWasmInitialized) {
49295 throw new Error("initializeWasm() must be awaited first!");
49297 const nativeResponseValue = wasm.TS_ForwardNode_new(tlvs_arg, node_id_arg, htlc_maximum_msat_arg);
49298 return nativeResponseValue;
49300 // uint64_t ForwardNode_clone_ptr(LDKForwardNode *NONNULL_PTR arg);
49302 export function ForwardNode_clone_ptr(arg: bigint): bigint {
49303 if(!isWasmInitialized) {
49304 throw new Error("initializeWasm() must be awaited first!");
49306 const nativeResponseValue = wasm.TS_ForwardNode_clone_ptr(arg);
49307 return nativeResponseValue;
49309 // struct LDKForwardNode ForwardNode_clone(const struct LDKForwardNode *NONNULL_PTR orig);
49311 export function ForwardNode_clone(orig: bigint): bigint {
49312 if(!isWasmInitialized) {
49313 throw new Error("initializeWasm() must be awaited first!");
49315 const nativeResponseValue = wasm.TS_ForwardNode_clone(orig);
49316 return nativeResponseValue;
49318 // void ForwardTlvs_free(struct LDKForwardTlvs this_obj);
49320 export function ForwardTlvs_free(this_obj: bigint): void {
49321 if(!isWasmInitialized) {
49322 throw new Error("initializeWasm() must be awaited first!");
49324 const nativeResponseValue = wasm.TS_ForwardTlvs_free(this_obj);
49325 // debug statements here
49327 // uint64_t ForwardTlvs_get_short_channel_id(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
49329 export function ForwardTlvs_get_short_channel_id(this_ptr: bigint): bigint {
49330 if(!isWasmInitialized) {
49331 throw new Error("initializeWasm() must be awaited first!");
49333 const nativeResponseValue = wasm.TS_ForwardTlvs_get_short_channel_id(this_ptr);
49334 return nativeResponseValue;
49336 // void ForwardTlvs_set_short_channel_id(struct LDKForwardTlvs *NONNULL_PTR this_ptr, uint64_t val);
49338 export function ForwardTlvs_set_short_channel_id(this_ptr: bigint, val: bigint): void {
49339 if(!isWasmInitialized) {
49340 throw new Error("initializeWasm() must be awaited first!");
49342 const nativeResponseValue = wasm.TS_ForwardTlvs_set_short_channel_id(this_ptr, val);
49343 // debug statements here
49345 // struct LDKPaymentRelay ForwardTlvs_get_payment_relay(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
49347 export function ForwardTlvs_get_payment_relay(this_ptr: bigint): bigint {
49348 if(!isWasmInitialized) {
49349 throw new Error("initializeWasm() must be awaited first!");
49351 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_relay(this_ptr);
49352 return nativeResponseValue;
49354 // void ForwardTlvs_set_payment_relay(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentRelay val);
49356 export function ForwardTlvs_set_payment_relay(this_ptr: bigint, val: bigint): void {
49357 if(!isWasmInitialized) {
49358 throw new Error("initializeWasm() must be awaited first!");
49360 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_relay(this_ptr, val);
49361 // debug statements here
49363 // struct LDKPaymentConstraints ForwardTlvs_get_payment_constraints(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
49365 export function ForwardTlvs_get_payment_constraints(this_ptr: bigint): bigint {
49366 if(!isWasmInitialized) {
49367 throw new Error("initializeWasm() must be awaited first!");
49369 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_constraints(this_ptr);
49370 return nativeResponseValue;
49372 // void ForwardTlvs_set_payment_constraints(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
49374 export function ForwardTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
49375 if(!isWasmInitialized) {
49376 throw new Error("initializeWasm() must be awaited first!");
49378 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_constraints(this_ptr, val);
49379 // debug statements here
49381 // struct LDKBlindedHopFeatures ForwardTlvs_get_features(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
49383 export function ForwardTlvs_get_features(this_ptr: bigint): bigint {
49384 if(!isWasmInitialized) {
49385 throw new Error("initializeWasm() must be awaited first!");
49387 const nativeResponseValue = wasm.TS_ForwardTlvs_get_features(this_ptr);
49388 return nativeResponseValue;
49390 // void ForwardTlvs_set_features(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
49392 export function ForwardTlvs_set_features(this_ptr: bigint, val: bigint): void {
49393 if(!isWasmInitialized) {
49394 throw new Error("initializeWasm() must be awaited first!");
49396 const nativeResponseValue = wasm.TS_ForwardTlvs_set_features(this_ptr, val);
49397 // debug statements here
49399 // MUST_USE_RES struct LDKForwardTlvs ForwardTlvs_new(uint64_t short_channel_id_arg, struct LDKPaymentRelay payment_relay_arg, struct LDKPaymentConstraints payment_constraints_arg, struct LDKBlindedHopFeatures features_arg);
49401 export function ForwardTlvs_new(short_channel_id_arg: bigint, payment_relay_arg: bigint, payment_constraints_arg: bigint, features_arg: bigint): bigint {
49402 if(!isWasmInitialized) {
49403 throw new Error("initializeWasm() must be awaited first!");
49405 const nativeResponseValue = wasm.TS_ForwardTlvs_new(short_channel_id_arg, payment_relay_arg, payment_constraints_arg, features_arg);
49406 return nativeResponseValue;
49408 // uint64_t ForwardTlvs_clone_ptr(LDKForwardTlvs *NONNULL_PTR arg);
49410 export function ForwardTlvs_clone_ptr(arg: bigint): bigint {
49411 if(!isWasmInitialized) {
49412 throw new Error("initializeWasm() must be awaited first!");
49414 const nativeResponseValue = wasm.TS_ForwardTlvs_clone_ptr(arg);
49415 return nativeResponseValue;
49417 // struct LDKForwardTlvs ForwardTlvs_clone(const struct LDKForwardTlvs *NONNULL_PTR orig);
49419 export function ForwardTlvs_clone(orig: bigint): bigint {
49420 if(!isWasmInitialized) {
49421 throw new Error("initializeWasm() must be awaited first!");
49423 const nativeResponseValue = wasm.TS_ForwardTlvs_clone(orig);
49424 return nativeResponseValue;
49426 // void ReceiveTlvs_free(struct LDKReceiveTlvs this_obj);
49428 export function ReceiveTlvs_free(this_obj: bigint): void {
49429 if(!isWasmInitialized) {
49430 throw new Error("initializeWasm() must be awaited first!");
49432 const nativeResponseValue = wasm.TS_ReceiveTlvs_free(this_obj);
49433 // debug statements here
49435 // const uint8_t (*ReceiveTlvs_get_payment_secret(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr))[32];
49437 export function ReceiveTlvs_get_payment_secret(this_ptr: bigint): number {
49438 if(!isWasmInitialized) {
49439 throw new Error("initializeWasm() must be awaited first!");
49441 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_secret(this_ptr);
49442 return nativeResponseValue;
49444 // void ReceiveTlvs_set_payment_secret(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
49446 export function ReceiveTlvs_set_payment_secret(this_ptr: bigint, val: number): void {
49447 if(!isWasmInitialized) {
49448 throw new Error("initializeWasm() must be awaited first!");
49450 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_secret(this_ptr, val);
49451 // debug statements here
49453 // struct LDKPaymentConstraints ReceiveTlvs_get_payment_constraints(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr);
49455 export function ReceiveTlvs_get_payment_constraints(this_ptr: bigint): bigint {
49456 if(!isWasmInitialized) {
49457 throw new Error("initializeWasm() must be awaited first!");
49459 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_constraints(this_ptr);
49460 return nativeResponseValue;
49462 // void ReceiveTlvs_set_payment_constraints(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
49464 export function ReceiveTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
49465 if(!isWasmInitialized) {
49466 throw new Error("initializeWasm() must be awaited first!");
49468 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_constraints(this_ptr, val);
49469 // debug statements here
49471 // MUST_USE_RES struct LDKReceiveTlvs ReceiveTlvs_new(struct LDKThirtyTwoBytes payment_secret_arg, struct LDKPaymentConstraints payment_constraints_arg);
49473 export function ReceiveTlvs_new(payment_secret_arg: number, payment_constraints_arg: bigint): bigint {
49474 if(!isWasmInitialized) {
49475 throw new Error("initializeWasm() must be awaited first!");
49477 const nativeResponseValue = wasm.TS_ReceiveTlvs_new(payment_secret_arg, payment_constraints_arg);
49478 return nativeResponseValue;
49480 // uint64_t ReceiveTlvs_clone_ptr(LDKReceiveTlvs *NONNULL_PTR arg);
49482 export function ReceiveTlvs_clone_ptr(arg: bigint): bigint {
49483 if(!isWasmInitialized) {
49484 throw new Error("initializeWasm() must be awaited first!");
49486 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone_ptr(arg);
49487 return nativeResponseValue;
49489 // struct LDKReceiveTlvs ReceiveTlvs_clone(const struct LDKReceiveTlvs *NONNULL_PTR orig);
49491 export function ReceiveTlvs_clone(orig: bigint): bigint {
49492 if(!isWasmInitialized) {
49493 throw new Error("initializeWasm() must be awaited first!");
49495 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone(orig);
49496 return nativeResponseValue;
49498 // void PaymentRelay_free(struct LDKPaymentRelay this_obj);
49500 export function PaymentRelay_free(this_obj: bigint): void {
49501 if(!isWasmInitialized) {
49502 throw new Error("initializeWasm() must be awaited first!");
49504 const nativeResponseValue = wasm.TS_PaymentRelay_free(this_obj);
49505 // debug statements here
49507 // uint16_t PaymentRelay_get_cltv_expiry_delta(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
49509 export function PaymentRelay_get_cltv_expiry_delta(this_ptr: bigint): number {
49510 if(!isWasmInitialized) {
49511 throw new Error("initializeWasm() must be awaited first!");
49513 const nativeResponseValue = wasm.TS_PaymentRelay_get_cltv_expiry_delta(this_ptr);
49514 return nativeResponseValue;
49516 // void PaymentRelay_set_cltv_expiry_delta(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint16_t val);
49518 export function PaymentRelay_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
49519 if(!isWasmInitialized) {
49520 throw new Error("initializeWasm() must be awaited first!");
49522 const nativeResponseValue = wasm.TS_PaymentRelay_set_cltv_expiry_delta(this_ptr, val);
49523 // debug statements here
49525 // uint32_t PaymentRelay_get_fee_proportional_millionths(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
49527 export function PaymentRelay_get_fee_proportional_millionths(this_ptr: bigint): number {
49528 if(!isWasmInitialized) {
49529 throw new Error("initializeWasm() must be awaited first!");
49531 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_proportional_millionths(this_ptr);
49532 return nativeResponseValue;
49534 // void PaymentRelay_set_fee_proportional_millionths(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
49536 export function PaymentRelay_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
49537 if(!isWasmInitialized) {
49538 throw new Error("initializeWasm() must be awaited first!");
49540 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_proportional_millionths(this_ptr, val);
49541 // debug statements here
49543 // uint32_t PaymentRelay_get_fee_base_msat(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
49545 export function PaymentRelay_get_fee_base_msat(this_ptr: bigint): number {
49546 if(!isWasmInitialized) {
49547 throw new Error("initializeWasm() must be awaited first!");
49549 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_base_msat(this_ptr);
49550 return nativeResponseValue;
49552 // void PaymentRelay_set_fee_base_msat(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
49554 export function PaymentRelay_set_fee_base_msat(this_ptr: bigint, val: number): void {
49555 if(!isWasmInitialized) {
49556 throw new Error("initializeWasm() must be awaited first!");
49558 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_base_msat(this_ptr, val);
49559 // debug statements here
49561 // MUST_USE_RES struct LDKPaymentRelay PaymentRelay_new(uint16_t cltv_expiry_delta_arg, uint32_t fee_proportional_millionths_arg, uint32_t fee_base_msat_arg);
49563 export function PaymentRelay_new(cltv_expiry_delta_arg: number, fee_proportional_millionths_arg: number, fee_base_msat_arg: number): bigint {
49564 if(!isWasmInitialized) {
49565 throw new Error("initializeWasm() must be awaited first!");
49567 const nativeResponseValue = wasm.TS_PaymentRelay_new(cltv_expiry_delta_arg, fee_proportional_millionths_arg, fee_base_msat_arg);
49568 return nativeResponseValue;
49570 // uint64_t PaymentRelay_clone_ptr(LDKPaymentRelay *NONNULL_PTR arg);
49572 export function PaymentRelay_clone_ptr(arg: bigint): bigint {
49573 if(!isWasmInitialized) {
49574 throw new Error("initializeWasm() must be awaited first!");
49576 const nativeResponseValue = wasm.TS_PaymentRelay_clone_ptr(arg);
49577 return nativeResponseValue;
49579 // struct LDKPaymentRelay PaymentRelay_clone(const struct LDKPaymentRelay *NONNULL_PTR orig);
49581 export function PaymentRelay_clone(orig: bigint): bigint {
49582 if(!isWasmInitialized) {
49583 throw new Error("initializeWasm() must be awaited first!");
49585 const nativeResponseValue = wasm.TS_PaymentRelay_clone(orig);
49586 return nativeResponseValue;
49588 // void PaymentConstraints_free(struct LDKPaymentConstraints this_obj);
49590 export function PaymentConstraints_free(this_obj: bigint): void {
49591 if(!isWasmInitialized) {
49592 throw new Error("initializeWasm() must be awaited first!");
49594 const nativeResponseValue = wasm.TS_PaymentConstraints_free(this_obj);
49595 // debug statements here
49597 // uint32_t PaymentConstraints_get_max_cltv_expiry(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
49599 export function PaymentConstraints_get_max_cltv_expiry(this_ptr: bigint): number {
49600 if(!isWasmInitialized) {
49601 throw new Error("initializeWasm() must be awaited first!");
49603 const nativeResponseValue = wasm.TS_PaymentConstraints_get_max_cltv_expiry(this_ptr);
49604 return nativeResponseValue;
49606 // void PaymentConstraints_set_max_cltv_expiry(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint32_t val);
49608 export function PaymentConstraints_set_max_cltv_expiry(this_ptr: bigint, val: number): void {
49609 if(!isWasmInitialized) {
49610 throw new Error("initializeWasm() must be awaited first!");
49612 const nativeResponseValue = wasm.TS_PaymentConstraints_set_max_cltv_expiry(this_ptr, val);
49613 // debug statements here
49615 // uint64_t PaymentConstraints_get_htlc_minimum_msat(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
49617 export function PaymentConstraints_get_htlc_minimum_msat(this_ptr: bigint): bigint {
49618 if(!isWasmInitialized) {
49619 throw new Error("initializeWasm() must be awaited first!");
49621 const nativeResponseValue = wasm.TS_PaymentConstraints_get_htlc_minimum_msat(this_ptr);
49622 return nativeResponseValue;
49624 // void PaymentConstraints_set_htlc_minimum_msat(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint64_t val);
49626 export function PaymentConstraints_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
49627 if(!isWasmInitialized) {
49628 throw new Error("initializeWasm() must be awaited first!");
49630 const nativeResponseValue = wasm.TS_PaymentConstraints_set_htlc_minimum_msat(this_ptr, val);
49631 // debug statements here
49633 // MUST_USE_RES struct LDKPaymentConstraints PaymentConstraints_new(uint32_t max_cltv_expiry_arg, uint64_t htlc_minimum_msat_arg);
49635 export function PaymentConstraints_new(max_cltv_expiry_arg: number, htlc_minimum_msat_arg: bigint): bigint {
49636 if(!isWasmInitialized) {
49637 throw new Error("initializeWasm() must be awaited first!");
49639 const nativeResponseValue = wasm.TS_PaymentConstraints_new(max_cltv_expiry_arg, htlc_minimum_msat_arg);
49640 return nativeResponseValue;
49642 // uint64_t PaymentConstraints_clone_ptr(LDKPaymentConstraints *NONNULL_PTR arg);
49644 export function PaymentConstraints_clone_ptr(arg: bigint): bigint {
49645 if(!isWasmInitialized) {
49646 throw new Error("initializeWasm() must be awaited first!");
49648 const nativeResponseValue = wasm.TS_PaymentConstraints_clone_ptr(arg);
49649 return nativeResponseValue;
49651 // struct LDKPaymentConstraints PaymentConstraints_clone(const struct LDKPaymentConstraints *NONNULL_PTR orig);
49653 export function PaymentConstraints_clone(orig: bigint): bigint {
49654 if(!isWasmInitialized) {
49655 throw new Error("initializeWasm() must be awaited first!");
49657 const nativeResponseValue = wasm.TS_PaymentConstraints_clone(orig);
49658 return nativeResponseValue;
49660 // struct LDKCVec_u8Z ForwardTlvs_write(const struct LDKForwardTlvs *NONNULL_PTR obj);
49662 export function ForwardTlvs_write(obj: bigint): number {
49663 if(!isWasmInitialized) {
49664 throw new Error("initializeWasm() must be awaited first!");
49666 const nativeResponseValue = wasm.TS_ForwardTlvs_write(obj);
49667 return nativeResponseValue;
49669 // struct LDKCVec_u8Z ReceiveTlvs_write(const struct LDKReceiveTlvs *NONNULL_PTR obj);
49671 export function ReceiveTlvs_write(obj: bigint): number {
49672 if(!isWasmInitialized) {
49673 throw new Error("initializeWasm() must be awaited first!");
49675 const nativeResponseValue = wasm.TS_ReceiveTlvs_write(obj);
49676 return nativeResponseValue;
49678 // struct LDKCResult_ReceiveTlvsDecodeErrorZ ReceiveTlvs_read(struct LDKu8slice ser);
49680 export function ReceiveTlvs_read(ser: number): bigint {
49681 if(!isWasmInitialized) {
49682 throw new Error("initializeWasm() must be awaited first!");
49684 const nativeResponseValue = wasm.TS_ReceiveTlvs_read(ser);
49685 return nativeResponseValue;
49687 // struct LDKCVec_u8Z PaymentRelay_write(const struct LDKPaymentRelay *NONNULL_PTR obj);
49689 export function PaymentRelay_write(obj: bigint): number {
49690 if(!isWasmInitialized) {
49691 throw new Error("initializeWasm() must be awaited first!");
49693 const nativeResponseValue = wasm.TS_PaymentRelay_write(obj);
49694 return nativeResponseValue;
49696 // struct LDKCResult_PaymentRelayDecodeErrorZ PaymentRelay_read(struct LDKu8slice ser);
49698 export function PaymentRelay_read(ser: number): bigint {
49699 if(!isWasmInitialized) {
49700 throw new Error("initializeWasm() must be awaited first!");
49702 const nativeResponseValue = wasm.TS_PaymentRelay_read(ser);
49703 return nativeResponseValue;
49705 // struct LDKCVec_u8Z PaymentConstraints_write(const struct LDKPaymentConstraints *NONNULL_PTR obj);
49707 export function PaymentConstraints_write(obj: bigint): number {
49708 if(!isWasmInitialized) {
49709 throw new Error("initializeWasm() must be awaited first!");
49711 const nativeResponseValue = wasm.TS_PaymentConstraints_write(obj);
49712 return nativeResponseValue;
49714 // struct LDKCResult_PaymentConstraintsDecodeErrorZ PaymentConstraints_read(struct LDKu8slice ser);
49716 export function PaymentConstraints_read(ser: number): bigint {
49717 if(!isWasmInitialized) {
49718 throw new Error("initializeWasm() must be awaited first!");
49720 const nativeResponseValue = wasm.TS_PaymentConstraints_read(ser);
49721 return nativeResponseValue;
49723 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
49725 export function PaymentPurpose_free(this_ptr: bigint): void {
49726 if(!isWasmInitialized) {
49727 throw new Error("initializeWasm() must be awaited first!");
49729 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
49730 // debug statements here
49732 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
49734 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
49735 if(!isWasmInitialized) {
49736 throw new Error("initializeWasm() must be awaited first!");
49738 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
49739 return nativeResponseValue;
49741 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
49743 export function PaymentPurpose_clone(orig: bigint): bigint {
49744 if(!isWasmInitialized) {
49745 throw new Error("initializeWasm() must be awaited first!");
49747 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
49748 return nativeResponseValue;
49750 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKThirtyTwoBytes payment_secret);
49752 export function PaymentPurpose_invoice_payment(payment_preimage: bigint, payment_secret: number): bigint {
49753 if(!isWasmInitialized) {
49754 throw new Error("initializeWasm() must be awaited first!");
49756 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
49757 return nativeResponseValue;
49759 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
49761 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
49762 if(!isWasmInitialized) {
49763 throw new Error("initializeWasm() must be awaited first!");
49765 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
49766 return nativeResponseValue;
49768 // bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
49770 export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
49771 if(!isWasmInitialized) {
49772 throw new Error("initializeWasm() must be awaited first!");
49774 const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
49775 return nativeResponseValue;
49777 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
49779 export function PaymentPurpose_write(obj: bigint): number {
49780 if(!isWasmInitialized) {
49781 throw new Error("initializeWasm() must be awaited first!");
49783 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
49784 return nativeResponseValue;
49786 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
49788 export function PaymentPurpose_read(ser: number): bigint {
49789 if(!isWasmInitialized) {
49790 throw new Error("initializeWasm() must be awaited first!");
49792 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
49793 return nativeResponseValue;
49795 // void ClaimedHTLC_free(struct LDKClaimedHTLC this_obj);
49797 export function ClaimedHTLC_free(this_obj: bigint): void {
49798 if(!isWasmInitialized) {
49799 throw new Error("initializeWasm() must be awaited first!");
49801 const nativeResponseValue = wasm.TS_ClaimedHTLC_free(this_obj);
49802 // debug statements here
49804 // const uint8_t (*ClaimedHTLC_get_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr))[32];
49806 export function ClaimedHTLC_get_channel_id(this_ptr: bigint): number {
49807 if(!isWasmInitialized) {
49808 throw new Error("initializeWasm() must be awaited first!");
49810 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_channel_id(this_ptr);
49811 return nativeResponseValue;
49813 // void ClaimedHTLC_set_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
49815 export function ClaimedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
49816 if(!isWasmInitialized) {
49817 throw new Error("initializeWasm() must be awaited first!");
49819 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_channel_id(this_ptr, val);
49820 // debug statements here
49822 // struct LDKU128 ClaimedHTLC_get_user_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
49824 export function ClaimedHTLC_get_user_channel_id(this_ptr: bigint): number {
49825 if(!isWasmInitialized) {
49826 throw new Error("initializeWasm() must be awaited first!");
49828 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_user_channel_id(this_ptr);
49829 return nativeResponseValue;
49831 // void ClaimedHTLC_set_user_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKU128 val);
49833 export function ClaimedHTLC_set_user_channel_id(this_ptr: bigint, val: number): void {
49834 if(!isWasmInitialized) {
49835 throw new Error("initializeWasm() must be awaited first!");
49837 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_user_channel_id(this_ptr, val);
49838 // debug statements here
49840 // uint32_t ClaimedHTLC_get_cltv_expiry(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
49842 export function ClaimedHTLC_get_cltv_expiry(this_ptr: bigint): number {
49843 if(!isWasmInitialized) {
49844 throw new Error("initializeWasm() must be awaited first!");
49846 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_cltv_expiry(this_ptr);
49847 return nativeResponseValue;
49849 // void ClaimedHTLC_set_cltv_expiry(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint32_t val);
49851 export function ClaimedHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
49852 if(!isWasmInitialized) {
49853 throw new Error("initializeWasm() must be awaited first!");
49855 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_cltv_expiry(this_ptr, val);
49856 // debug statements here
49858 // uint64_t ClaimedHTLC_get_value_msat(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
49860 export function ClaimedHTLC_get_value_msat(this_ptr: bigint): bigint {
49861 if(!isWasmInitialized) {
49862 throw new Error("initializeWasm() must be awaited first!");
49864 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_value_msat(this_ptr);
49865 return nativeResponseValue;
49867 // void ClaimedHTLC_set_value_msat(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint64_t val);
49869 export function ClaimedHTLC_set_value_msat(this_ptr: bigint, val: bigint): void {
49870 if(!isWasmInitialized) {
49871 throw new Error("initializeWasm() must be awaited first!");
49873 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_value_msat(this_ptr, val);
49874 // debug statements here
49876 // MUST_USE_RES struct LDKClaimedHTLC ClaimedHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKU128 user_channel_id_arg, uint32_t cltv_expiry_arg, uint64_t value_msat_arg);
49878 export function ClaimedHTLC_new(channel_id_arg: number, user_channel_id_arg: number, cltv_expiry_arg: number, value_msat_arg: bigint): bigint {
49879 if(!isWasmInitialized) {
49880 throw new Error("initializeWasm() must be awaited first!");
49882 const nativeResponseValue = wasm.TS_ClaimedHTLC_new(channel_id_arg, user_channel_id_arg, cltv_expiry_arg, value_msat_arg);
49883 return nativeResponseValue;
49885 // uint64_t ClaimedHTLC_clone_ptr(LDKClaimedHTLC *NONNULL_PTR arg);
49887 export function ClaimedHTLC_clone_ptr(arg: bigint): bigint {
49888 if(!isWasmInitialized) {
49889 throw new Error("initializeWasm() must be awaited first!");
49891 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone_ptr(arg);
49892 return nativeResponseValue;
49894 // struct LDKClaimedHTLC ClaimedHTLC_clone(const struct LDKClaimedHTLC *NONNULL_PTR orig);
49896 export function ClaimedHTLC_clone(orig: bigint): bigint {
49897 if(!isWasmInitialized) {
49898 throw new Error("initializeWasm() must be awaited first!");
49900 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone(orig);
49901 return nativeResponseValue;
49903 // bool ClaimedHTLC_eq(const struct LDKClaimedHTLC *NONNULL_PTR a, const struct LDKClaimedHTLC *NONNULL_PTR b);
49905 export function ClaimedHTLC_eq(a: bigint, b: bigint): boolean {
49906 if(!isWasmInitialized) {
49907 throw new Error("initializeWasm() must be awaited first!");
49909 const nativeResponseValue = wasm.TS_ClaimedHTLC_eq(a, b);
49910 return nativeResponseValue;
49912 // struct LDKCVec_u8Z ClaimedHTLC_write(const struct LDKClaimedHTLC *NONNULL_PTR obj);
49914 export function ClaimedHTLC_write(obj: bigint): number {
49915 if(!isWasmInitialized) {
49916 throw new Error("initializeWasm() must be awaited first!");
49918 const nativeResponseValue = wasm.TS_ClaimedHTLC_write(obj);
49919 return nativeResponseValue;
49921 // struct LDKCResult_ClaimedHTLCDecodeErrorZ ClaimedHTLC_read(struct LDKu8slice ser);
49923 export function ClaimedHTLC_read(ser: number): bigint {
49924 if(!isWasmInitialized) {
49925 throw new Error("initializeWasm() must be awaited first!");
49927 const nativeResponseValue = wasm.TS_ClaimedHTLC_read(ser);
49928 return nativeResponseValue;
49930 // void PathFailure_free(struct LDKPathFailure this_ptr);
49932 export function PathFailure_free(this_ptr: bigint): void {
49933 if(!isWasmInitialized) {
49934 throw new Error("initializeWasm() must be awaited first!");
49936 const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
49937 // debug statements here
49939 // uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
49941 export function PathFailure_clone_ptr(arg: bigint): bigint {
49942 if(!isWasmInitialized) {
49943 throw new Error("initializeWasm() must be awaited first!");
49945 const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
49946 return nativeResponseValue;
49948 // struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
49950 export function PathFailure_clone(orig: bigint): bigint {
49951 if(!isWasmInitialized) {
49952 throw new Error("initializeWasm() must be awaited first!");
49954 const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
49955 return nativeResponseValue;
49957 // struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
49959 export function PathFailure_initial_send(err: bigint): bigint {
49960 if(!isWasmInitialized) {
49961 throw new Error("initializeWasm() must be awaited first!");
49963 const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
49964 return nativeResponseValue;
49966 // struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
49968 export function PathFailure_on_path(network_update: bigint): bigint {
49969 if(!isWasmInitialized) {
49970 throw new Error("initializeWasm() must be awaited first!");
49972 const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
49973 return nativeResponseValue;
49975 // bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
49977 export function PathFailure_eq(a: bigint, b: bigint): boolean {
49978 if(!isWasmInitialized) {
49979 throw new Error("initializeWasm() must be awaited first!");
49981 const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
49982 return nativeResponseValue;
49984 // struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
49986 export function PathFailure_write(obj: bigint): number {
49987 if(!isWasmInitialized) {
49988 throw new Error("initializeWasm() must be awaited first!");
49990 const nativeResponseValue = wasm.TS_PathFailure_write(obj);
49991 return nativeResponseValue;
49993 // struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
49995 export function PathFailure_read(ser: number): bigint {
49996 if(!isWasmInitialized) {
49997 throw new Error("initializeWasm() must be awaited first!");
49999 const nativeResponseValue = wasm.TS_PathFailure_read(ser);
50000 return nativeResponseValue;
50002 // void ClosureReason_free(struct LDKClosureReason this_ptr);
50004 export function ClosureReason_free(this_ptr: bigint): void {
50005 if(!isWasmInitialized) {
50006 throw new Error("initializeWasm() must be awaited first!");
50008 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
50009 // debug statements here
50011 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
50013 export function ClosureReason_clone_ptr(arg: bigint): bigint {
50014 if(!isWasmInitialized) {
50015 throw new Error("initializeWasm() must be awaited first!");
50017 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
50018 return nativeResponseValue;
50020 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
50022 export function ClosureReason_clone(orig: bigint): bigint {
50023 if(!isWasmInitialized) {
50024 throw new Error("initializeWasm() must be awaited first!");
50026 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
50027 return nativeResponseValue;
50029 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKUntrustedString peer_msg);
50031 export function ClosureReason_counterparty_force_closed(peer_msg: bigint): bigint {
50032 if(!isWasmInitialized) {
50033 throw new Error("initializeWasm() must be awaited first!");
50035 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
50036 return nativeResponseValue;
50038 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
50040 export function ClosureReason_holder_force_closed(): bigint {
50041 if(!isWasmInitialized) {
50042 throw new Error("initializeWasm() must be awaited first!");
50044 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
50045 return nativeResponseValue;
50047 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
50049 export function ClosureReason_cooperative_closure(): bigint {
50050 if(!isWasmInitialized) {
50051 throw new Error("initializeWasm() must be awaited first!");
50053 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
50054 return nativeResponseValue;
50056 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
50058 export function ClosureReason_commitment_tx_confirmed(): bigint {
50059 if(!isWasmInitialized) {
50060 throw new Error("initializeWasm() must be awaited first!");
50062 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
50063 return nativeResponseValue;
50065 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
50067 export function ClosureReason_funding_timed_out(): bigint {
50068 if(!isWasmInitialized) {
50069 throw new Error("initializeWasm() must be awaited first!");
50071 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
50072 return nativeResponseValue;
50074 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
50076 export function ClosureReason_processing_error(err: number): bigint {
50077 if(!isWasmInitialized) {
50078 throw new Error("initializeWasm() must be awaited first!");
50080 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
50081 return nativeResponseValue;
50083 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
50085 export function ClosureReason_disconnected_peer(): bigint {
50086 if(!isWasmInitialized) {
50087 throw new Error("initializeWasm() must be awaited first!");
50089 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
50090 return nativeResponseValue;
50092 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
50094 export function ClosureReason_outdated_channel_manager(): bigint {
50095 if(!isWasmInitialized) {
50096 throw new Error("initializeWasm() must be awaited first!");
50098 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
50099 return nativeResponseValue;
50101 // struct LDKClosureReason ClosureReason_counterparty_coop_closed_unfunded_channel(void);
50103 export function ClosureReason_counterparty_coop_closed_unfunded_channel(): bigint {
50104 if(!isWasmInitialized) {
50105 throw new Error("initializeWasm() must be awaited first!");
50107 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_coop_closed_unfunded_channel();
50108 return nativeResponseValue;
50110 // struct LDKClosureReason ClosureReason_funding_batch_closure(void);
50112 export function ClosureReason_funding_batch_closure(): bigint {
50113 if(!isWasmInitialized) {
50114 throw new Error("initializeWasm() must be awaited first!");
50116 const nativeResponseValue = wasm.TS_ClosureReason_funding_batch_closure();
50117 return nativeResponseValue;
50119 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
50121 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
50122 if(!isWasmInitialized) {
50123 throw new Error("initializeWasm() must be awaited first!");
50125 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
50126 return nativeResponseValue;
50128 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
50130 export function ClosureReason_write(obj: bigint): number {
50131 if(!isWasmInitialized) {
50132 throw new Error("initializeWasm() must be awaited first!");
50134 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
50135 return nativeResponseValue;
50137 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
50139 export function ClosureReason_read(ser: number): bigint {
50140 if(!isWasmInitialized) {
50141 throw new Error("initializeWasm() must be awaited first!");
50143 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
50144 return nativeResponseValue;
50146 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
50148 export function HTLCDestination_free(this_ptr: bigint): void {
50149 if(!isWasmInitialized) {
50150 throw new Error("initializeWasm() must be awaited first!");
50152 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
50153 // debug statements here
50155 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
50157 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
50158 if(!isWasmInitialized) {
50159 throw new Error("initializeWasm() must be awaited first!");
50161 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
50162 return nativeResponseValue;
50164 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
50166 export function HTLCDestination_clone(orig: bigint): bigint {
50167 if(!isWasmInitialized) {
50168 throw new Error("initializeWasm() must be awaited first!");
50170 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
50171 return nativeResponseValue;
50173 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
50175 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
50176 if(!isWasmInitialized) {
50177 throw new Error("initializeWasm() must be awaited first!");
50179 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
50180 return nativeResponseValue;
50182 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
50184 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
50185 if(!isWasmInitialized) {
50186 throw new Error("initializeWasm() must be awaited first!");
50188 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
50189 return nativeResponseValue;
50191 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
50193 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
50194 if(!isWasmInitialized) {
50195 throw new Error("initializeWasm() must be awaited first!");
50197 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
50198 return nativeResponseValue;
50200 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
50202 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
50203 if(!isWasmInitialized) {
50204 throw new Error("initializeWasm() must be awaited first!");
50206 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
50207 return nativeResponseValue;
50209 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
50211 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
50212 if(!isWasmInitialized) {
50213 throw new Error("initializeWasm() must be awaited first!");
50215 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
50216 return nativeResponseValue;
50218 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
50220 export function HTLCDestination_write(obj: bigint): number {
50221 if(!isWasmInitialized) {
50222 throw new Error("initializeWasm() must be awaited first!");
50224 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
50225 return nativeResponseValue;
50227 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
50229 export function HTLCDestination_read(ser: number): bigint {
50230 if(!isWasmInitialized) {
50231 throw new Error("initializeWasm() must be awaited first!");
50233 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
50234 return nativeResponseValue;
50236 // enum LDKPaymentFailureReason PaymentFailureReason_clone(const enum LDKPaymentFailureReason *NONNULL_PTR orig);
50238 export function PaymentFailureReason_clone(orig: bigint): PaymentFailureReason {
50239 if(!isWasmInitialized) {
50240 throw new Error("initializeWasm() must be awaited first!");
50242 const nativeResponseValue = wasm.TS_PaymentFailureReason_clone(orig);
50243 return nativeResponseValue;
50245 // enum LDKPaymentFailureReason PaymentFailureReason_recipient_rejected(void);
50247 export function PaymentFailureReason_recipient_rejected(): PaymentFailureReason {
50248 if(!isWasmInitialized) {
50249 throw new Error("initializeWasm() must be awaited first!");
50251 const nativeResponseValue = wasm.TS_PaymentFailureReason_recipient_rejected();
50252 return nativeResponseValue;
50254 // enum LDKPaymentFailureReason PaymentFailureReason_user_abandoned(void);
50256 export function PaymentFailureReason_user_abandoned(): PaymentFailureReason {
50257 if(!isWasmInitialized) {
50258 throw new Error("initializeWasm() must be awaited first!");
50260 const nativeResponseValue = wasm.TS_PaymentFailureReason_user_abandoned();
50261 return nativeResponseValue;
50263 // enum LDKPaymentFailureReason PaymentFailureReason_retries_exhausted(void);
50265 export function PaymentFailureReason_retries_exhausted(): PaymentFailureReason {
50266 if(!isWasmInitialized) {
50267 throw new Error("initializeWasm() must be awaited first!");
50269 const nativeResponseValue = wasm.TS_PaymentFailureReason_retries_exhausted();
50270 return nativeResponseValue;
50272 // enum LDKPaymentFailureReason PaymentFailureReason_payment_expired(void);
50274 export function PaymentFailureReason_payment_expired(): PaymentFailureReason {
50275 if(!isWasmInitialized) {
50276 throw new Error("initializeWasm() must be awaited first!");
50278 const nativeResponseValue = wasm.TS_PaymentFailureReason_payment_expired();
50279 return nativeResponseValue;
50281 // enum LDKPaymentFailureReason PaymentFailureReason_route_not_found(void);
50283 export function PaymentFailureReason_route_not_found(): PaymentFailureReason {
50284 if(!isWasmInitialized) {
50285 throw new Error("initializeWasm() must be awaited first!");
50287 const nativeResponseValue = wasm.TS_PaymentFailureReason_route_not_found();
50288 return nativeResponseValue;
50290 // enum LDKPaymentFailureReason PaymentFailureReason_unexpected_error(void);
50292 export function PaymentFailureReason_unexpected_error(): PaymentFailureReason {
50293 if(!isWasmInitialized) {
50294 throw new Error("initializeWasm() must be awaited first!");
50296 const nativeResponseValue = wasm.TS_PaymentFailureReason_unexpected_error();
50297 return nativeResponseValue;
50299 // bool PaymentFailureReason_eq(const enum LDKPaymentFailureReason *NONNULL_PTR a, const enum LDKPaymentFailureReason *NONNULL_PTR b);
50301 export function PaymentFailureReason_eq(a: bigint, b: bigint): boolean {
50302 if(!isWasmInitialized) {
50303 throw new Error("initializeWasm() must be awaited first!");
50305 const nativeResponseValue = wasm.TS_PaymentFailureReason_eq(a, b);
50306 return nativeResponseValue;
50308 // struct LDKCVec_u8Z PaymentFailureReason_write(const enum LDKPaymentFailureReason *NONNULL_PTR obj);
50310 export function PaymentFailureReason_write(obj: bigint): number {
50311 if(!isWasmInitialized) {
50312 throw new Error("initializeWasm() must be awaited first!");
50314 const nativeResponseValue = wasm.TS_PaymentFailureReason_write(obj);
50315 return nativeResponseValue;
50317 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ PaymentFailureReason_read(struct LDKu8slice ser);
50319 export function PaymentFailureReason_read(ser: number): bigint {
50320 if(!isWasmInitialized) {
50321 throw new Error("initializeWasm() must be awaited first!");
50323 const nativeResponseValue = wasm.TS_PaymentFailureReason_read(ser);
50324 return nativeResponseValue;
50326 // void Event_free(struct LDKEvent this_ptr);
50328 export function Event_free(this_ptr: bigint): void {
50329 if(!isWasmInitialized) {
50330 throw new Error("initializeWasm() must be awaited first!");
50332 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
50333 // debug statements here
50335 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
50337 export function Event_clone_ptr(arg: bigint): bigint {
50338 if(!isWasmInitialized) {
50339 throw new Error("initializeWasm() must be awaited first!");
50341 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
50342 return nativeResponseValue;
50344 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
50346 export function Event_clone(orig: bigint): bigint {
50347 if(!isWasmInitialized) {
50348 throw new Error("initializeWasm() must be awaited first!");
50350 const nativeResponseValue = wasm.TS_Event_clone(orig);
50351 return nativeResponseValue;
50353 // 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);
50355 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 {
50356 if(!isWasmInitialized) {
50357 throw new Error("initializeWasm() must be awaited first!");
50359 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
50360 return nativeResponseValue;
50362 // 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 LDKCOption_ThirtyTwoBytesZ via_channel_id, struct LDKCOption_U128Z via_user_channel_id, struct LDKCOption_u32Z claim_deadline);
50364 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: bigint, via_user_channel_id: bigint, claim_deadline: bigint): bigint {
50365 if(!isWasmInitialized) {
50366 throw new Error("initializeWasm() must be awaited first!");
50368 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);
50369 return nativeResponseValue;
50371 // struct LDKEvent Event_payment_claimed(struct LDKPublicKey receiver_node_id, struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose, struct LDKCVec_ClaimedHTLCZ htlcs, struct LDKCOption_u64Z sender_intended_total_msat);
50373 export function Event_payment_claimed(receiver_node_id: number, payment_hash: number, amount_msat: bigint, purpose: bigint, htlcs: number, sender_intended_total_msat: bigint): bigint {
50374 if(!isWasmInitialized) {
50375 throw new Error("initializeWasm() must be awaited first!");
50377 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose, htlcs, sender_intended_total_msat);
50378 return nativeResponseValue;
50380 // struct LDKEvent Event_payment_sent(struct LDKCOption_ThirtyTwoBytesZ payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
50382 export function Event_payment_sent(payment_id: bigint, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
50383 if(!isWasmInitialized) {
50384 throw new Error("initializeWasm() must be awaited first!");
50386 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
50387 return nativeResponseValue;
50389 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_PaymentFailureReasonZ reason);
50391 export function Event_payment_failed(payment_id: number, payment_hash: number, reason: bigint): bigint {
50392 if(!isWasmInitialized) {
50393 throw new Error("initializeWasm() must be awaited first!");
50395 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash, reason);
50396 return nativeResponseValue;
50398 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash, struct LDKPath path);
50400 export function Event_payment_path_successful(payment_id: number, payment_hash: bigint, path: bigint): bigint {
50401 if(!isWasmInitialized) {
50402 throw new Error("initializeWasm() must be awaited first!");
50404 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
50405 return nativeResponseValue;
50407 // struct LDKEvent Event_payment_path_failed(struct LDKCOption_ThirtyTwoBytesZ payment_id, struct LDKThirtyTwoBytes payment_hash, bool payment_failed_permanently, struct LDKPathFailure failure, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
50409 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 {
50410 if(!isWasmInitialized) {
50411 throw new Error("initializeWasm() must be awaited first!");
50413 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id);
50414 return nativeResponseValue;
50416 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
50418 export function Event_probe_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
50419 if(!isWasmInitialized) {
50420 throw new Error("initializeWasm() must be awaited first!");
50422 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
50423 return nativeResponseValue;
50425 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
50427 export function Event_probe_failed(payment_id: number, payment_hash: number, path: bigint, short_channel_id: bigint): bigint {
50428 if(!isWasmInitialized) {
50429 throw new Error("initializeWasm() must be awaited first!");
50431 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
50432 return nativeResponseValue;
50434 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
50436 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
50437 if(!isWasmInitialized) {
50438 throw new Error("initializeWasm() must be awaited first!");
50440 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
50441 return nativeResponseValue;
50443 // 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);
50445 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 {
50446 if(!isWasmInitialized) {
50447 throw new Error("initializeWasm() must be awaited first!");
50449 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
50450 return nativeResponseValue;
50452 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs, struct LDKCOption_ThirtyTwoBytesZ channel_id);
50454 export function Event_spendable_outputs(outputs: number, channel_id: bigint): bigint {
50455 if(!isWasmInitialized) {
50456 throw new Error("initializeWasm() must be awaited first!");
50458 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs, channel_id);
50459 return nativeResponseValue;
50461 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_ThirtyTwoBytesZ prev_channel_id, struct LDKCOption_ThirtyTwoBytesZ next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx, struct LDKCOption_u64Z outbound_amount_forwarded_msat);
50463 export function Event_payment_forwarded(prev_channel_id: bigint, next_channel_id: bigint, fee_earned_msat: bigint, claim_from_onchain_tx: boolean, outbound_amount_forwarded_msat: bigint): bigint {
50464 if(!isWasmInitialized) {
50465 throw new Error("initializeWasm() must be awaited first!");
50467 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx, outbound_amount_forwarded_msat);
50468 return nativeResponseValue;
50470 // struct LDKEvent Event_channel_pending(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKCOption_ThirtyTwoBytesZ former_temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKOutPoint funding_txo);
50472 export function Event_channel_pending(channel_id: number, user_channel_id: number, former_temporary_channel_id: bigint, counterparty_node_id: number, funding_txo: bigint): bigint {
50473 if(!isWasmInitialized) {
50474 throw new Error("initializeWasm() must be awaited first!");
50476 const nativeResponseValue = wasm.TS_Event_channel_pending(channel_id, user_channel_id, former_temporary_channel_id, counterparty_node_id, funding_txo);
50477 return nativeResponseValue;
50479 // struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
50481 export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
50482 if(!isWasmInitialized) {
50483 throw new Error("initializeWasm() must be awaited first!");
50485 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
50486 return nativeResponseValue;
50488 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason, struct LDKPublicKey counterparty_node_id, struct LDKCOption_u64Z channel_capacity_sats);
50490 export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint, counterparty_node_id: number, channel_capacity_sats: bigint): bigint {
50491 if(!isWasmInitialized) {
50492 throw new Error("initializeWasm() must be awaited first!");
50494 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason, counterparty_node_id, channel_capacity_sats);
50495 return nativeResponseValue;
50497 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
50499 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
50500 if(!isWasmInitialized) {
50501 throw new Error("initializeWasm() must be awaited first!");
50503 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
50504 return nativeResponseValue;
50506 // 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);
50508 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
50509 if(!isWasmInitialized) {
50510 throw new Error("initializeWasm() must be awaited first!");
50512 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
50513 return nativeResponseValue;
50515 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
50517 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
50518 if(!isWasmInitialized) {
50519 throw new Error("initializeWasm() must be awaited first!");
50521 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
50522 return nativeResponseValue;
50524 // struct LDKEvent Event_bump_transaction(struct LDKBumpTransactionEvent a);
50526 export function Event_bump_transaction(a: bigint): bigint {
50527 if(!isWasmInitialized) {
50528 throw new Error("initializeWasm() must be awaited first!");
50530 const nativeResponseValue = wasm.TS_Event_bump_transaction(a);
50531 return nativeResponseValue;
50533 // bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
50535 export function Event_eq(a: bigint, b: bigint): boolean {
50536 if(!isWasmInitialized) {
50537 throw new Error("initializeWasm() must be awaited first!");
50539 const nativeResponseValue = wasm.TS_Event_eq(a, b);
50540 return nativeResponseValue;
50542 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
50544 export function Event_write(obj: bigint): number {
50545 if(!isWasmInitialized) {
50546 throw new Error("initializeWasm() must be awaited first!");
50548 const nativeResponseValue = wasm.TS_Event_write(obj);
50549 return nativeResponseValue;
50551 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
50553 export function Event_read(ser: number): bigint {
50554 if(!isWasmInitialized) {
50555 throw new Error("initializeWasm() must be awaited first!");
50557 const nativeResponseValue = wasm.TS_Event_read(ser);
50558 return nativeResponseValue;
50560 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
50562 export function MessageSendEvent_free(this_ptr: bigint): void {
50563 if(!isWasmInitialized) {
50564 throw new Error("initializeWasm() must be awaited first!");
50566 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
50567 // debug statements here
50569 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
50571 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
50572 if(!isWasmInitialized) {
50573 throw new Error("initializeWasm() must be awaited first!");
50575 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
50576 return nativeResponseValue;
50578 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
50580 export function MessageSendEvent_clone(orig: bigint): bigint {
50581 if(!isWasmInitialized) {
50582 throw new Error("initializeWasm() must be awaited first!");
50584 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
50585 return nativeResponseValue;
50587 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
50589 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
50590 if(!isWasmInitialized) {
50591 throw new Error("initializeWasm() must be awaited first!");
50593 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
50594 return nativeResponseValue;
50596 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel_v2(struct LDKPublicKey node_id, struct LDKAcceptChannelV2 msg);
50598 export function MessageSendEvent_send_accept_channel_v2(node_id: number, msg: bigint): bigint {
50599 if(!isWasmInitialized) {
50600 throw new Error("initializeWasm() must be awaited first!");
50602 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel_v2(node_id, msg);
50603 return nativeResponseValue;
50605 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
50607 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
50608 if(!isWasmInitialized) {
50609 throw new Error("initializeWasm() must be awaited first!");
50611 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
50612 return nativeResponseValue;
50614 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel_v2(struct LDKPublicKey node_id, struct LDKOpenChannelV2 msg);
50616 export function MessageSendEvent_send_open_channel_v2(node_id: number, msg: bigint): bigint {
50617 if(!isWasmInitialized) {
50618 throw new Error("initializeWasm() must be awaited first!");
50620 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel_v2(node_id, msg);
50621 return nativeResponseValue;
50623 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
50625 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
50626 if(!isWasmInitialized) {
50627 throw new Error("initializeWasm() must be awaited first!");
50629 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
50630 return nativeResponseValue;
50632 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
50634 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
50635 if(!isWasmInitialized) {
50636 throw new Error("initializeWasm() must be awaited first!");
50638 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
50639 return nativeResponseValue;
50641 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_input(struct LDKPublicKey node_id, struct LDKTxAddInput msg);
50643 export function MessageSendEvent_send_tx_add_input(node_id: number, msg: bigint): bigint {
50644 if(!isWasmInitialized) {
50645 throw new Error("initializeWasm() must be awaited first!");
50647 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_input(node_id, msg);
50648 return nativeResponseValue;
50650 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_output(struct LDKPublicKey node_id, struct LDKTxAddOutput msg);
50652 export function MessageSendEvent_send_tx_add_output(node_id: number, msg: bigint): bigint {
50653 if(!isWasmInitialized) {
50654 throw new Error("initializeWasm() must be awaited first!");
50656 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_output(node_id, msg);
50657 return nativeResponseValue;
50659 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_input(struct LDKPublicKey node_id, struct LDKTxRemoveInput msg);
50661 export function MessageSendEvent_send_tx_remove_input(node_id: number, msg: bigint): bigint {
50662 if(!isWasmInitialized) {
50663 throw new Error("initializeWasm() must be awaited first!");
50665 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_input(node_id, msg);
50666 return nativeResponseValue;
50668 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_output(struct LDKPublicKey node_id, struct LDKTxRemoveOutput msg);
50670 export function MessageSendEvent_send_tx_remove_output(node_id: number, msg: bigint): bigint {
50671 if(!isWasmInitialized) {
50672 throw new Error("initializeWasm() must be awaited first!");
50674 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_output(node_id, msg);
50675 return nativeResponseValue;
50677 // struct LDKMessageSendEvent MessageSendEvent_send_tx_complete(struct LDKPublicKey node_id, struct LDKTxComplete msg);
50679 export function MessageSendEvent_send_tx_complete(node_id: number, msg: bigint): bigint {
50680 if(!isWasmInitialized) {
50681 throw new Error("initializeWasm() must be awaited first!");
50683 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_complete(node_id, msg);
50684 return nativeResponseValue;
50686 // struct LDKMessageSendEvent MessageSendEvent_send_tx_signatures(struct LDKPublicKey node_id, struct LDKTxSignatures msg);
50688 export function MessageSendEvent_send_tx_signatures(node_id: number, msg: bigint): bigint {
50689 if(!isWasmInitialized) {
50690 throw new Error("initializeWasm() must be awaited first!");
50692 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_signatures(node_id, msg);
50693 return nativeResponseValue;
50695 // struct LDKMessageSendEvent MessageSendEvent_send_tx_init_rbf(struct LDKPublicKey node_id, struct LDKTxInitRbf msg);
50697 export function MessageSendEvent_send_tx_init_rbf(node_id: number, msg: bigint): bigint {
50698 if(!isWasmInitialized) {
50699 throw new Error("initializeWasm() must be awaited first!");
50701 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_init_rbf(node_id, msg);
50702 return nativeResponseValue;
50704 // struct LDKMessageSendEvent MessageSendEvent_send_tx_ack_rbf(struct LDKPublicKey node_id, struct LDKTxAckRbf msg);
50706 export function MessageSendEvent_send_tx_ack_rbf(node_id: number, msg: bigint): bigint {
50707 if(!isWasmInitialized) {
50708 throw new Error("initializeWasm() must be awaited first!");
50710 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_ack_rbf(node_id, msg);
50711 return nativeResponseValue;
50713 // struct LDKMessageSendEvent MessageSendEvent_send_tx_abort(struct LDKPublicKey node_id, struct LDKTxAbort msg);
50715 export function MessageSendEvent_send_tx_abort(node_id: number, msg: bigint): bigint {
50716 if(!isWasmInitialized) {
50717 throw new Error("initializeWasm() must be awaited first!");
50719 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_abort(node_id, msg);
50720 return nativeResponseValue;
50722 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
50724 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
50725 if(!isWasmInitialized) {
50726 throw new Error("initializeWasm() must be awaited first!");
50728 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
50729 return nativeResponseValue;
50731 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
50733 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
50734 if(!isWasmInitialized) {
50735 throw new Error("initializeWasm() must be awaited first!");
50737 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
50738 return nativeResponseValue;
50740 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
50742 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
50743 if(!isWasmInitialized) {
50744 throw new Error("initializeWasm() must be awaited first!");
50746 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
50747 return nativeResponseValue;
50749 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
50751 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
50752 if(!isWasmInitialized) {
50753 throw new Error("initializeWasm() must be awaited first!");
50755 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
50756 return nativeResponseValue;
50758 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
50760 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
50761 if(!isWasmInitialized) {
50762 throw new Error("initializeWasm() must be awaited first!");
50764 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
50765 return nativeResponseValue;
50767 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
50769 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
50770 if(!isWasmInitialized) {
50771 throw new Error("initializeWasm() must be awaited first!");
50773 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
50774 return nativeResponseValue;
50776 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
50778 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
50779 if(!isWasmInitialized) {
50780 throw new Error("initializeWasm() must be awaited first!");
50782 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
50783 return nativeResponseValue;
50785 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
50787 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
50788 if(!isWasmInitialized) {
50789 throw new Error("initializeWasm() must be awaited first!");
50791 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
50792 return nativeResponseValue;
50794 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
50796 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
50797 if(!isWasmInitialized) {
50798 throw new Error("initializeWasm() must be awaited first!");
50800 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
50801 return nativeResponseValue;
50803 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
50805 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
50806 if(!isWasmInitialized) {
50807 throw new Error("initializeWasm() must be awaited first!");
50809 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
50810 return nativeResponseValue;
50812 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
50814 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
50815 if(!isWasmInitialized) {
50816 throw new Error("initializeWasm() must be awaited first!");
50818 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
50819 return nativeResponseValue;
50821 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
50823 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
50824 if(!isWasmInitialized) {
50825 throw new Error("initializeWasm() must be awaited first!");
50827 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
50828 return nativeResponseValue;
50830 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
50832 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
50833 if(!isWasmInitialized) {
50834 throw new Error("initializeWasm() must be awaited first!");
50836 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
50837 return nativeResponseValue;
50839 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
50841 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
50842 if(!isWasmInitialized) {
50843 throw new Error("initializeWasm() must be awaited first!");
50845 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
50846 return nativeResponseValue;
50848 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
50850 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
50851 if(!isWasmInitialized) {
50852 throw new Error("initializeWasm() must be awaited first!");
50854 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
50855 return nativeResponseValue;
50857 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
50859 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
50860 if(!isWasmInitialized) {
50861 throw new Error("initializeWasm() must be awaited first!");
50863 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
50864 return nativeResponseValue;
50866 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
50868 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
50869 if(!isWasmInitialized) {
50870 throw new Error("initializeWasm() must be awaited first!");
50872 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
50873 return nativeResponseValue;
50875 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
50877 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
50878 if(!isWasmInitialized) {
50879 throw new Error("initializeWasm() must be awaited first!");
50881 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
50882 // debug statements here
50884 // void OnionMessageProvider_free(struct LDKOnionMessageProvider this_ptr);
50886 export function OnionMessageProvider_free(this_ptr: bigint): void {
50887 if(!isWasmInitialized) {
50888 throw new Error("initializeWasm() must be awaited first!");
50890 const nativeResponseValue = wasm.TS_OnionMessageProvider_free(this_ptr);
50891 // debug statements here
50893 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
50895 export function EventsProvider_free(this_ptr: bigint): void {
50896 if(!isWasmInitialized) {
50897 throw new Error("initializeWasm() must be awaited first!");
50899 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
50900 // debug statements here
50902 // void EventHandler_free(struct LDKEventHandler this_ptr);
50904 export function EventHandler_free(this_ptr: bigint): void {
50905 if(!isWasmInitialized) {
50906 throw new Error("initializeWasm() must be awaited first!");
50908 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
50909 // debug statements here
50911 // void ChannelDerivationParameters_free(struct LDKChannelDerivationParameters this_obj);
50913 export function ChannelDerivationParameters_free(this_obj: bigint): void {
50914 if(!isWasmInitialized) {
50915 throw new Error("initializeWasm() must be awaited first!");
50917 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_free(this_obj);
50918 // debug statements here
50920 // uint64_t ChannelDerivationParameters_get_value_satoshis(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
50922 export function ChannelDerivationParameters_get_value_satoshis(this_ptr: bigint): bigint {
50923 if(!isWasmInitialized) {
50924 throw new Error("initializeWasm() must be awaited first!");
50926 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_value_satoshis(this_ptr);
50927 return nativeResponseValue;
50929 // void ChannelDerivationParameters_set_value_satoshis(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, uint64_t val);
50931 export function ChannelDerivationParameters_set_value_satoshis(this_ptr: bigint, val: bigint): void {
50932 if(!isWasmInitialized) {
50933 throw new Error("initializeWasm() must be awaited first!");
50935 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_value_satoshis(this_ptr, val);
50936 // debug statements here
50938 // const uint8_t (*ChannelDerivationParameters_get_keys_id(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr))[32];
50940 export function ChannelDerivationParameters_get_keys_id(this_ptr: bigint): number {
50941 if(!isWasmInitialized) {
50942 throw new Error("initializeWasm() must be awaited first!");
50944 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_keys_id(this_ptr);
50945 return nativeResponseValue;
50947 // void ChannelDerivationParameters_set_keys_id(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
50949 export function ChannelDerivationParameters_set_keys_id(this_ptr: bigint, val: number): void {
50950 if(!isWasmInitialized) {
50951 throw new Error("initializeWasm() must be awaited first!");
50953 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_keys_id(this_ptr, val);
50954 // debug statements here
50956 // struct LDKChannelTransactionParameters ChannelDerivationParameters_get_transaction_parameters(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
50958 export function ChannelDerivationParameters_get_transaction_parameters(this_ptr: bigint): bigint {
50959 if(!isWasmInitialized) {
50960 throw new Error("initializeWasm() must be awaited first!");
50962 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_transaction_parameters(this_ptr);
50963 return nativeResponseValue;
50965 // void ChannelDerivationParameters_set_transaction_parameters(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
50967 export function ChannelDerivationParameters_set_transaction_parameters(this_ptr: bigint, val: bigint): void {
50968 if(!isWasmInitialized) {
50969 throw new Error("initializeWasm() must be awaited first!");
50971 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_transaction_parameters(this_ptr, val);
50972 // debug statements here
50974 // MUST_USE_RES struct LDKChannelDerivationParameters ChannelDerivationParameters_new(uint64_t value_satoshis_arg, struct LDKThirtyTwoBytes keys_id_arg, struct LDKChannelTransactionParameters transaction_parameters_arg);
50976 export function ChannelDerivationParameters_new(value_satoshis_arg: bigint, keys_id_arg: number, transaction_parameters_arg: bigint): bigint {
50977 if(!isWasmInitialized) {
50978 throw new Error("initializeWasm() must be awaited first!");
50980 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg, transaction_parameters_arg);
50981 return nativeResponseValue;
50983 // uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg);
50985 export function ChannelDerivationParameters_clone_ptr(arg: bigint): bigint {
50986 if(!isWasmInitialized) {
50987 throw new Error("initializeWasm() must be awaited first!");
50989 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone_ptr(arg);
50990 return nativeResponseValue;
50992 // struct LDKChannelDerivationParameters ChannelDerivationParameters_clone(const struct LDKChannelDerivationParameters *NONNULL_PTR orig);
50994 export function ChannelDerivationParameters_clone(orig: bigint): bigint {
50995 if(!isWasmInitialized) {
50996 throw new Error("initializeWasm() must be awaited first!");
50998 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone(orig);
50999 return nativeResponseValue;
51001 // bool ChannelDerivationParameters_eq(const struct LDKChannelDerivationParameters *NONNULL_PTR a, const struct LDKChannelDerivationParameters *NONNULL_PTR b);
51003 export function ChannelDerivationParameters_eq(a: bigint, b: bigint): boolean {
51004 if(!isWasmInitialized) {
51005 throw new Error("initializeWasm() must be awaited first!");
51007 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_eq(a, b);
51008 return nativeResponseValue;
51010 // struct LDKCVec_u8Z ChannelDerivationParameters_write(const struct LDKChannelDerivationParameters *NONNULL_PTR obj);
51012 export function ChannelDerivationParameters_write(obj: bigint): number {
51013 if(!isWasmInitialized) {
51014 throw new Error("initializeWasm() must be awaited first!");
51016 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_write(obj);
51017 return nativeResponseValue;
51019 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ ChannelDerivationParameters_read(struct LDKu8slice ser);
51021 export function ChannelDerivationParameters_read(ser: number): bigint {
51022 if(!isWasmInitialized) {
51023 throw new Error("initializeWasm() must be awaited first!");
51025 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_read(ser);
51026 return nativeResponseValue;
51028 // void AnchorDescriptor_free(struct LDKAnchorDescriptor this_obj);
51030 export function AnchorDescriptor_free(this_obj: bigint): void {
51031 if(!isWasmInitialized) {
51032 throw new Error("initializeWasm() must be awaited first!");
51034 const nativeResponseValue = wasm.TS_AnchorDescriptor_free(this_obj);
51035 // debug statements here
51037 // struct LDKChannelDerivationParameters AnchorDescriptor_get_channel_derivation_parameters(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
51039 export function AnchorDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
51040 if(!isWasmInitialized) {
51041 throw new Error("initializeWasm() must be awaited first!");
51043 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_channel_derivation_parameters(this_ptr);
51044 return nativeResponseValue;
51046 // void AnchorDescriptor_set_channel_derivation_parameters(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
51048 export function AnchorDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
51049 if(!isWasmInitialized) {
51050 throw new Error("initializeWasm() must be awaited first!");
51052 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_channel_derivation_parameters(this_ptr, val);
51053 // debug statements here
51055 // struct LDKOutPoint AnchorDescriptor_get_outpoint(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
51057 export function AnchorDescriptor_get_outpoint(this_ptr: bigint): bigint {
51058 if(!isWasmInitialized) {
51059 throw new Error("initializeWasm() must be awaited first!");
51061 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_outpoint(this_ptr);
51062 return nativeResponseValue;
51064 // void AnchorDescriptor_set_outpoint(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
51066 export function AnchorDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
51067 if(!isWasmInitialized) {
51068 throw new Error("initializeWasm() must be awaited first!");
51070 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_outpoint(this_ptr, val);
51071 // debug statements here
51073 // MUST_USE_RES struct LDKAnchorDescriptor AnchorDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKOutPoint outpoint_arg);
51075 export function AnchorDescriptor_new(channel_derivation_parameters_arg: bigint, outpoint_arg: bigint): bigint {
51076 if(!isWasmInitialized) {
51077 throw new Error("initializeWasm() must be awaited first!");
51079 const nativeResponseValue = wasm.TS_AnchorDescriptor_new(channel_derivation_parameters_arg, outpoint_arg);
51080 return nativeResponseValue;
51082 // uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg);
51084 export function AnchorDescriptor_clone_ptr(arg: bigint): bigint {
51085 if(!isWasmInitialized) {
51086 throw new Error("initializeWasm() must be awaited first!");
51088 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone_ptr(arg);
51089 return nativeResponseValue;
51091 // struct LDKAnchorDescriptor AnchorDescriptor_clone(const struct LDKAnchorDescriptor *NONNULL_PTR orig);
51093 export function AnchorDescriptor_clone(orig: bigint): bigint {
51094 if(!isWasmInitialized) {
51095 throw new Error("initializeWasm() must be awaited first!");
51097 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone(orig);
51098 return nativeResponseValue;
51100 // bool AnchorDescriptor_eq(const struct LDKAnchorDescriptor *NONNULL_PTR a, const struct LDKAnchorDescriptor *NONNULL_PTR b);
51102 export function AnchorDescriptor_eq(a: bigint, b: bigint): boolean {
51103 if(!isWasmInitialized) {
51104 throw new Error("initializeWasm() must be awaited first!");
51106 const nativeResponseValue = wasm.TS_AnchorDescriptor_eq(a, b);
51107 return nativeResponseValue;
51109 // MUST_USE_RES struct LDKTxOut AnchorDescriptor_previous_utxo(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
51111 export function AnchorDescriptor_previous_utxo(this_arg: bigint): bigint {
51112 if(!isWasmInitialized) {
51113 throw new Error("initializeWasm() must be awaited first!");
51115 const nativeResponseValue = wasm.TS_AnchorDescriptor_previous_utxo(this_arg);
51116 return nativeResponseValue;
51118 // MUST_USE_RES struct LDKTxIn AnchorDescriptor_unsigned_tx_input(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
51120 export function AnchorDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
51121 if(!isWasmInitialized) {
51122 throw new Error("initializeWasm() must be awaited first!");
51124 const nativeResponseValue = wasm.TS_AnchorDescriptor_unsigned_tx_input(this_arg);
51125 return nativeResponseValue;
51127 // MUST_USE_RES struct LDKCVec_u8Z AnchorDescriptor_witness_script(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
51129 export function AnchorDescriptor_witness_script(this_arg: bigint): number {
51130 if(!isWasmInitialized) {
51131 throw new Error("initializeWasm() must be awaited first!");
51133 const nativeResponseValue = wasm.TS_AnchorDescriptor_witness_script(this_arg);
51134 return nativeResponseValue;
51136 // MUST_USE_RES struct LDKWitness AnchorDescriptor_tx_input_witness(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature);
51138 export function AnchorDescriptor_tx_input_witness(this_arg: bigint, signature: number): number {
51139 if(!isWasmInitialized) {
51140 throw new Error("initializeWasm() must be awaited first!");
51142 const nativeResponseValue = wasm.TS_AnchorDescriptor_tx_input_witness(this_arg, signature);
51143 return nativeResponseValue;
51145 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner AnchorDescriptor_derive_channel_signer(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
51147 export function AnchorDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
51148 if(!isWasmInitialized) {
51149 throw new Error("initializeWasm() must be awaited first!");
51151 const nativeResponseValue = wasm.TS_AnchorDescriptor_derive_channel_signer(this_arg, signer_provider);
51152 return nativeResponseValue;
51154 // void HTLCDescriptor_free(struct LDKHTLCDescriptor this_obj);
51156 export function HTLCDescriptor_free(this_obj: bigint): void {
51157 if(!isWasmInitialized) {
51158 throw new Error("initializeWasm() must be awaited first!");
51160 const nativeResponseValue = wasm.TS_HTLCDescriptor_free(this_obj);
51161 // debug statements here
51163 // struct LDKChannelDerivationParameters HTLCDescriptor_get_channel_derivation_parameters(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
51165 export function HTLCDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
51166 if(!isWasmInitialized) {
51167 throw new Error("initializeWasm() must be awaited first!");
51169 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_channel_derivation_parameters(this_ptr);
51170 return nativeResponseValue;
51172 // void HTLCDescriptor_set_channel_derivation_parameters(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
51174 export function HTLCDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
51175 if(!isWasmInitialized) {
51176 throw new Error("initializeWasm() must be awaited first!");
51178 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_channel_derivation_parameters(this_ptr, val);
51179 // debug statements here
51181 // uint64_t HTLCDescriptor_get_per_commitment_number(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
51183 export function HTLCDescriptor_get_per_commitment_number(this_ptr: bigint): bigint {
51184 if(!isWasmInitialized) {
51185 throw new Error("initializeWasm() must be awaited first!");
51187 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_number(this_ptr);
51188 return nativeResponseValue;
51190 // void HTLCDescriptor_set_per_commitment_number(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint64_t val);
51192 export function HTLCDescriptor_set_per_commitment_number(this_ptr: bigint, val: bigint): void {
51193 if(!isWasmInitialized) {
51194 throw new Error("initializeWasm() must be awaited first!");
51196 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_number(this_ptr, val);
51197 // debug statements here
51199 // struct LDKPublicKey HTLCDescriptor_get_per_commitment_point(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
51201 export function HTLCDescriptor_get_per_commitment_point(this_ptr: bigint): number {
51202 if(!isWasmInitialized) {
51203 throw new Error("initializeWasm() must be awaited first!");
51205 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_point(this_ptr);
51206 return nativeResponseValue;
51208 // void HTLCDescriptor_set_per_commitment_point(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
51210 export function HTLCDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
51211 if(!isWasmInitialized) {
51212 throw new Error("initializeWasm() must be awaited first!");
51214 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_point(this_ptr, val);
51215 // debug statements here
51217 // struct LDKHTLCOutputInCommitment HTLCDescriptor_get_htlc(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
51219 export function HTLCDescriptor_get_htlc(this_ptr: bigint): bigint {
51220 if(!isWasmInitialized) {
51221 throw new Error("initializeWasm() must be awaited first!");
51223 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_htlc(this_ptr);
51224 return nativeResponseValue;
51226 // void HTLCDescriptor_set_htlc(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKHTLCOutputInCommitment val);
51228 export function HTLCDescriptor_set_htlc(this_ptr: bigint, val: bigint): void {
51229 if(!isWasmInitialized) {
51230 throw new Error("initializeWasm() must be awaited first!");
51232 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_htlc(this_ptr, val);
51233 // debug statements here
51235 // struct LDKCOption_ThirtyTwoBytesZ HTLCDescriptor_get_preimage(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
51237 export function HTLCDescriptor_get_preimage(this_ptr: bigint): bigint {
51238 if(!isWasmInitialized) {
51239 throw new Error("initializeWasm() must be awaited first!");
51241 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_preimage(this_ptr);
51242 return nativeResponseValue;
51244 // void HTLCDescriptor_set_preimage(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
51246 export function HTLCDescriptor_set_preimage(this_ptr: bigint, val: bigint): void {
51247 if(!isWasmInitialized) {
51248 throw new Error("initializeWasm() must be awaited first!");
51250 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_preimage(this_ptr, val);
51251 // debug statements here
51253 // struct LDKECDSASignature HTLCDescriptor_get_counterparty_sig(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
51255 export function HTLCDescriptor_get_counterparty_sig(this_ptr: bigint): number {
51256 if(!isWasmInitialized) {
51257 throw new Error("initializeWasm() must be awaited first!");
51259 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_counterparty_sig(this_ptr);
51260 return nativeResponseValue;
51262 // void HTLCDescriptor_set_counterparty_sig(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
51264 export function HTLCDescriptor_set_counterparty_sig(this_ptr: bigint, val: number): void {
51265 if(!isWasmInitialized) {
51266 throw new Error("initializeWasm() must be awaited first!");
51268 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_counterparty_sig(this_ptr, val);
51269 // debug statements here
51271 // uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg);
51273 export function HTLCDescriptor_clone_ptr(arg: bigint): bigint {
51274 if(!isWasmInitialized) {
51275 throw new Error("initializeWasm() must be awaited first!");
51277 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone_ptr(arg);
51278 return nativeResponseValue;
51280 // struct LDKHTLCDescriptor HTLCDescriptor_clone(const struct LDKHTLCDescriptor *NONNULL_PTR orig);
51282 export function HTLCDescriptor_clone(orig: bigint): bigint {
51283 if(!isWasmInitialized) {
51284 throw new Error("initializeWasm() must be awaited first!");
51286 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone(orig);
51287 return nativeResponseValue;
51289 // bool HTLCDescriptor_eq(const struct LDKHTLCDescriptor *NONNULL_PTR a, const struct LDKHTLCDescriptor *NONNULL_PTR b);
51291 export function HTLCDescriptor_eq(a: bigint, b: bigint): boolean {
51292 if(!isWasmInitialized) {
51293 throw new Error("initializeWasm() must be awaited first!");
51295 const nativeResponseValue = wasm.TS_HTLCDescriptor_eq(a, b);
51296 return nativeResponseValue;
51298 // struct LDKCVec_u8Z HTLCDescriptor_write(const struct LDKHTLCDescriptor *NONNULL_PTR obj);
51300 export function HTLCDescriptor_write(obj: bigint): number {
51301 if(!isWasmInitialized) {
51302 throw new Error("initializeWasm() must be awaited first!");
51304 const nativeResponseValue = wasm.TS_HTLCDescriptor_write(obj);
51305 return nativeResponseValue;
51307 // struct LDKCResult_HTLCDescriptorDecodeErrorZ HTLCDescriptor_read(struct LDKu8slice ser);
51309 export function HTLCDescriptor_read(ser: number): bigint {
51310 if(!isWasmInitialized) {
51311 throw new Error("initializeWasm() must be awaited first!");
51313 const nativeResponseValue = wasm.TS_HTLCDescriptor_read(ser);
51314 return nativeResponseValue;
51316 // MUST_USE_RES struct LDKOutPoint HTLCDescriptor_outpoint(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
51318 export function HTLCDescriptor_outpoint(this_arg: bigint): bigint {
51319 if(!isWasmInitialized) {
51320 throw new Error("initializeWasm() must be awaited first!");
51322 const nativeResponseValue = wasm.TS_HTLCDescriptor_outpoint(this_arg);
51323 return nativeResponseValue;
51325 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_previous_utxo(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
51327 export function HTLCDescriptor_previous_utxo(this_arg: bigint): bigint {
51328 if(!isWasmInitialized) {
51329 throw new Error("initializeWasm() must be awaited first!");
51331 const nativeResponseValue = wasm.TS_HTLCDescriptor_previous_utxo(this_arg);
51332 return nativeResponseValue;
51334 // MUST_USE_RES struct LDKTxIn HTLCDescriptor_unsigned_tx_input(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
51336 export function HTLCDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
51337 if(!isWasmInitialized) {
51338 throw new Error("initializeWasm() must be awaited first!");
51340 const nativeResponseValue = wasm.TS_HTLCDescriptor_unsigned_tx_input(this_arg);
51341 return nativeResponseValue;
51343 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_tx_output(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
51345 export function HTLCDescriptor_tx_output(this_arg: bigint): bigint {
51346 if(!isWasmInitialized) {
51347 throw new Error("initializeWasm() must be awaited first!");
51349 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_output(this_arg);
51350 return nativeResponseValue;
51352 // MUST_USE_RES struct LDKCVec_u8Z HTLCDescriptor_witness_script(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
51354 export function HTLCDescriptor_witness_script(this_arg: bigint): number {
51355 if(!isWasmInitialized) {
51356 throw new Error("initializeWasm() must be awaited first!");
51358 const nativeResponseValue = wasm.TS_HTLCDescriptor_witness_script(this_arg);
51359 return nativeResponseValue;
51361 // MUST_USE_RES struct LDKWitness HTLCDescriptor_tx_input_witness(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature, struct LDKu8slice witness_script);
51363 export function HTLCDescriptor_tx_input_witness(this_arg: bigint, signature: number, witness_script: number): number {
51364 if(!isWasmInitialized) {
51365 throw new Error("initializeWasm() must be awaited first!");
51367 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_input_witness(this_arg, signature, witness_script);
51368 return nativeResponseValue;
51370 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner HTLCDescriptor_derive_channel_signer(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
51372 export function HTLCDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
51373 if(!isWasmInitialized) {
51374 throw new Error("initializeWasm() must be awaited first!");
51376 const nativeResponseValue = wasm.TS_HTLCDescriptor_derive_channel_signer(this_arg, signer_provider);
51377 return nativeResponseValue;
51379 // void BumpTransactionEvent_free(struct LDKBumpTransactionEvent this_ptr);
51381 export function BumpTransactionEvent_free(this_ptr: bigint): void {
51382 if(!isWasmInitialized) {
51383 throw new Error("initializeWasm() must be awaited first!");
51385 const nativeResponseValue = wasm.TS_BumpTransactionEvent_free(this_ptr);
51386 // debug statements here
51388 // uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg);
51390 export function BumpTransactionEvent_clone_ptr(arg: bigint): bigint {
51391 if(!isWasmInitialized) {
51392 throw new Error("initializeWasm() must be awaited first!");
51394 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone_ptr(arg);
51395 return nativeResponseValue;
51397 // struct LDKBumpTransactionEvent BumpTransactionEvent_clone(const struct LDKBumpTransactionEvent *NONNULL_PTR orig);
51399 export function BumpTransactionEvent_clone(orig: bigint): bigint {
51400 if(!isWasmInitialized) {
51401 throw new Error("initializeWasm() must be awaited first!");
51403 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone(orig);
51404 return nativeResponseValue;
51406 // 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);
51408 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 {
51409 if(!isWasmInitialized) {
51410 throw new Error("initializeWasm() must be awaited first!");
51412 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);
51413 return nativeResponseValue;
51415 // 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);
51417 export function BumpTransactionEvent_htlcresolution(claim_id: number, target_feerate_sat_per_1000_weight: number, htlc_descriptors: number, tx_lock_time: number): bigint {
51418 if(!isWasmInitialized) {
51419 throw new Error("initializeWasm() must be awaited first!");
51421 const nativeResponseValue = wasm.TS_BumpTransactionEvent_htlcresolution(claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time);
51422 return nativeResponseValue;
51424 // bool BumpTransactionEvent_eq(const struct LDKBumpTransactionEvent *NONNULL_PTR a, const struct LDKBumpTransactionEvent *NONNULL_PTR b);
51426 export function BumpTransactionEvent_eq(a: bigint, b: bigint): boolean {
51427 if(!isWasmInitialized) {
51428 throw new Error("initializeWasm() must be awaited first!");
51430 const nativeResponseValue = wasm.TS_BumpTransactionEvent_eq(a, b);
51431 return nativeResponseValue;
51433 // void Input_free(struct LDKInput this_obj);
51435 export function Input_free(this_obj: bigint): void {
51436 if(!isWasmInitialized) {
51437 throw new Error("initializeWasm() must be awaited first!");
51439 const nativeResponseValue = wasm.TS_Input_free(this_obj);
51440 // debug statements here
51442 // struct LDKOutPoint Input_get_outpoint(const struct LDKInput *NONNULL_PTR this_ptr);
51444 export function Input_get_outpoint(this_ptr: bigint): bigint {
51445 if(!isWasmInitialized) {
51446 throw new Error("initializeWasm() must be awaited first!");
51448 const nativeResponseValue = wasm.TS_Input_get_outpoint(this_ptr);
51449 return nativeResponseValue;
51451 // void Input_set_outpoint(struct LDKInput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
51453 export function Input_set_outpoint(this_ptr: bigint, val: bigint): void {
51454 if(!isWasmInitialized) {
51455 throw new Error("initializeWasm() must be awaited first!");
51457 const nativeResponseValue = wasm.TS_Input_set_outpoint(this_ptr, val);
51458 // debug statements here
51460 // struct LDKTxOut Input_get_previous_utxo(const struct LDKInput *NONNULL_PTR this_ptr);
51462 export function Input_get_previous_utxo(this_ptr: bigint): bigint {
51463 if(!isWasmInitialized) {
51464 throw new Error("initializeWasm() must be awaited first!");
51466 const nativeResponseValue = wasm.TS_Input_get_previous_utxo(this_ptr);
51467 return nativeResponseValue;
51469 // void Input_set_previous_utxo(struct LDKInput *NONNULL_PTR this_ptr, struct LDKTxOut val);
51471 export function Input_set_previous_utxo(this_ptr: bigint, val: bigint): void {
51472 if(!isWasmInitialized) {
51473 throw new Error("initializeWasm() must be awaited first!");
51475 const nativeResponseValue = wasm.TS_Input_set_previous_utxo(this_ptr, val);
51476 // debug statements here
51478 // uint64_t Input_get_satisfaction_weight(const struct LDKInput *NONNULL_PTR this_ptr);
51480 export function Input_get_satisfaction_weight(this_ptr: bigint): bigint {
51481 if(!isWasmInitialized) {
51482 throw new Error("initializeWasm() must be awaited first!");
51484 const nativeResponseValue = wasm.TS_Input_get_satisfaction_weight(this_ptr);
51485 return nativeResponseValue;
51487 // void Input_set_satisfaction_weight(struct LDKInput *NONNULL_PTR this_ptr, uint64_t val);
51489 export function Input_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
51490 if(!isWasmInitialized) {
51491 throw new Error("initializeWasm() must be awaited first!");
51493 const nativeResponseValue = wasm.TS_Input_set_satisfaction_weight(this_ptr, val);
51494 // debug statements here
51496 // MUST_USE_RES struct LDKInput Input_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut previous_utxo_arg, uint64_t satisfaction_weight_arg);
51498 export function Input_new(outpoint_arg: bigint, previous_utxo_arg: bigint, satisfaction_weight_arg: bigint): bigint {
51499 if(!isWasmInitialized) {
51500 throw new Error("initializeWasm() must be awaited first!");
51502 const nativeResponseValue = wasm.TS_Input_new(outpoint_arg, previous_utxo_arg, satisfaction_weight_arg);
51503 return nativeResponseValue;
51505 // uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg);
51507 export function Input_clone_ptr(arg: bigint): bigint {
51508 if(!isWasmInitialized) {
51509 throw new Error("initializeWasm() must be awaited first!");
51511 const nativeResponseValue = wasm.TS_Input_clone_ptr(arg);
51512 return nativeResponseValue;
51514 // struct LDKInput Input_clone(const struct LDKInput *NONNULL_PTR orig);
51516 export function Input_clone(orig: bigint): bigint {
51517 if(!isWasmInitialized) {
51518 throw new Error("initializeWasm() must be awaited first!");
51520 const nativeResponseValue = wasm.TS_Input_clone(orig);
51521 return nativeResponseValue;
51523 // uint64_t Input_hash(const struct LDKInput *NONNULL_PTR o);
51525 export function Input_hash(o: bigint): bigint {
51526 if(!isWasmInitialized) {
51527 throw new Error("initializeWasm() must be awaited first!");
51529 const nativeResponseValue = wasm.TS_Input_hash(o);
51530 return nativeResponseValue;
51532 // bool Input_eq(const struct LDKInput *NONNULL_PTR a, const struct LDKInput *NONNULL_PTR b);
51534 export function Input_eq(a: bigint, b: bigint): boolean {
51535 if(!isWasmInitialized) {
51536 throw new Error("initializeWasm() must be awaited first!");
51538 const nativeResponseValue = wasm.TS_Input_eq(a, b);
51539 return nativeResponseValue;
51541 // void Utxo_free(struct LDKUtxo this_obj);
51543 export function Utxo_free(this_obj: bigint): void {
51544 if(!isWasmInitialized) {
51545 throw new Error("initializeWasm() must be awaited first!");
51547 const nativeResponseValue = wasm.TS_Utxo_free(this_obj);
51548 // debug statements here
51550 // struct LDKOutPoint Utxo_get_outpoint(const struct LDKUtxo *NONNULL_PTR this_ptr);
51552 export function Utxo_get_outpoint(this_ptr: bigint): bigint {
51553 if(!isWasmInitialized) {
51554 throw new Error("initializeWasm() must be awaited first!");
51556 const nativeResponseValue = wasm.TS_Utxo_get_outpoint(this_ptr);
51557 return nativeResponseValue;
51559 // void Utxo_set_outpoint(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKOutPoint val);
51561 export function Utxo_set_outpoint(this_ptr: bigint, val: bigint): void {
51562 if(!isWasmInitialized) {
51563 throw new Error("initializeWasm() must be awaited first!");
51565 const nativeResponseValue = wasm.TS_Utxo_set_outpoint(this_ptr, val);
51566 // debug statements here
51568 // struct LDKTxOut Utxo_get_output(const struct LDKUtxo *NONNULL_PTR this_ptr);
51570 export function Utxo_get_output(this_ptr: bigint): bigint {
51571 if(!isWasmInitialized) {
51572 throw new Error("initializeWasm() must be awaited first!");
51574 const nativeResponseValue = wasm.TS_Utxo_get_output(this_ptr);
51575 return nativeResponseValue;
51577 // void Utxo_set_output(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKTxOut val);
51579 export function Utxo_set_output(this_ptr: bigint, val: bigint): void {
51580 if(!isWasmInitialized) {
51581 throw new Error("initializeWasm() must be awaited first!");
51583 const nativeResponseValue = wasm.TS_Utxo_set_output(this_ptr, val);
51584 // debug statements here
51586 // uint64_t Utxo_get_satisfaction_weight(const struct LDKUtxo *NONNULL_PTR this_ptr);
51588 export function Utxo_get_satisfaction_weight(this_ptr: bigint): bigint {
51589 if(!isWasmInitialized) {
51590 throw new Error("initializeWasm() must be awaited first!");
51592 const nativeResponseValue = wasm.TS_Utxo_get_satisfaction_weight(this_ptr);
51593 return nativeResponseValue;
51595 // void Utxo_set_satisfaction_weight(struct LDKUtxo *NONNULL_PTR this_ptr, uint64_t val);
51597 export function Utxo_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
51598 if(!isWasmInitialized) {
51599 throw new Error("initializeWasm() must be awaited first!");
51601 const nativeResponseValue = wasm.TS_Utxo_set_satisfaction_weight(this_ptr, val);
51602 // debug statements here
51604 // MUST_USE_RES struct LDKUtxo Utxo_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, uint64_t satisfaction_weight_arg);
51606 export function Utxo_new(outpoint_arg: bigint, output_arg: bigint, satisfaction_weight_arg: bigint): bigint {
51607 if(!isWasmInitialized) {
51608 throw new Error("initializeWasm() must be awaited first!");
51610 const nativeResponseValue = wasm.TS_Utxo_new(outpoint_arg, output_arg, satisfaction_weight_arg);
51611 return nativeResponseValue;
51613 // uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg);
51615 export function Utxo_clone_ptr(arg: bigint): bigint {
51616 if(!isWasmInitialized) {
51617 throw new Error("initializeWasm() must be awaited first!");
51619 const nativeResponseValue = wasm.TS_Utxo_clone_ptr(arg);
51620 return nativeResponseValue;
51622 // struct LDKUtxo Utxo_clone(const struct LDKUtxo *NONNULL_PTR orig);
51624 export function Utxo_clone(orig: bigint): bigint {
51625 if(!isWasmInitialized) {
51626 throw new Error("initializeWasm() must be awaited first!");
51628 const nativeResponseValue = wasm.TS_Utxo_clone(orig);
51629 return nativeResponseValue;
51631 // uint64_t Utxo_hash(const struct LDKUtxo *NONNULL_PTR o);
51633 export function Utxo_hash(o: bigint): bigint {
51634 if(!isWasmInitialized) {
51635 throw new Error("initializeWasm() must be awaited first!");
51637 const nativeResponseValue = wasm.TS_Utxo_hash(o);
51638 return nativeResponseValue;
51640 // bool Utxo_eq(const struct LDKUtxo *NONNULL_PTR a, const struct LDKUtxo *NONNULL_PTR b);
51642 export function Utxo_eq(a: bigint, b: bigint): boolean {
51643 if(!isWasmInitialized) {
51644 throw new Error("initializeWasm() must be awaited first!");
51646 const nativeResponseValue = wasm.TS_Utxo_eq(a, b);
51647 return nativeResponseValue;
51649 // MUST_USE_RES struct LDKUtxo Utxo_new_p2pkh(struct LDKOutPoint outpoint, uint64_t value, const uint8_t (*pubkey_hash)[20]);
51651 export function Utxo_new_p2pkh(outpoint: bigint, value: bigint, pubkey_hash: number): bigint {
51652 if(!isWasmInitialized) {
51653 throw new Error("initializeWasm() must be awaited first!");
51655 const nativeResponseValue = wasm.TS_Utxo_new_p2pkh(outpoint, value, pubkey_hash);
51656 return nativeResponseValue;
51658 // void CoinSelection_free(struct LDKCoinSelection this_obj);
51660 export function CoinSelection_free(this_obj: bigint): void {
51661 if(!isWasmInitialized) {
51662 throw new Error("initializeWasm() must be awaited first!");
51664 const nativeResponseValue = wasm.TS_CoinSelection_free(this_obj);
51665 // debug statements here
51667 // struct LDKCVec_UtxoZ CoinSelection_get_confirmed_utxos(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
51669 export function CoinSelection_get_confirmed_utxos(this_ptr: bigint): number {
51670 if(!isWasmInitialized) {
51671 throw new Error("initializeWasm() must be awaited first!");
51673 const nativeResponseValue = wasm.TS_CoinSelection_get_confirmed_utxos(this_ptr);
51674 return nativeResponseValue;
51676 // void CoinSelection_set_confirmed_utxos(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCVec_UtxoZ val);
51678 export function CoinSelection_set_confirmed_utxos(this_ptr: bigint, val: number): void {
51679 if(!isWasmInitialized) {
51680 throw new Error("initializeWasm() must be awaited first!");
51682 const nativeResponseValue = wasm.TS_CoinSelection_set_confirmed_utxos(this_ptr, val);
51683 // debug statements here
51685 // struct LDKCOption_TxOutZ CoinSelection_get_change_output(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
51687 export function CoinSelection_get_change_output(this_ptr: bigint): bigint {
51688 if(!isWasmInitialized) {
51689 throw new Error("initializeWasm() must be awaited first!");
51691 const nativeResponseValue = wasm.TS_CoinSelection_get_change_output(this_ptr);
51692 return nativeResponseValue;
51694 // void CoinSelection_set_change_output(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCOption_TxOutZ val);
51696 export function CoinSelection_set_change_output(this_ptr: bigint, val: bigint): void {
51697 if(!isWasmInitialized) {
51698 throw new Error("initializeWasm() must be awaited first!");
51700 const nativeResponseValue = wasm.TS_CoinSelection_set_change_output(this_ptr, val);
51701 // debug statements here
51703 // MUST_USE_RES struct LDKCoinSelection CoinSelection_new(struct LDKCVec_UtxoZ confirmed_utxos_arg, struct LDKCOption_TxOutZ change_output_arg);
51705 export function CoinSelection_new(confirmed_utxos_arg: number, change_output_arg: bigint): bigint {
51706 if(!isWasmInitialized) {
51707 throw new Error("initializeWasm() must be awaited first!");
51709 const nativeResponseValue = wasm.TS_CoinSelection_new(confirmed_utxos_arg, change_output_arg);
51710 return nativeResponseValue;
51712 // uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg);
51714 export function CoinSelection_clone_ptr(arg: bigint): bigint {
51715 if(!isWasmInitialized) {
51716 throw new Error("initializeWasm() must be awaited first!");
51718 const nativeResponseValue = wasm.TS_CoinSelection_clone_ptr(arg);
51719 return nativeResponseValue;
51721 // struct LDKCoinSelection CoinSelection_clone(const struct LDKCoinSelection *NONNULL_PTR orig);
51723 export function CoinSelection_clone(orig: bigint): bigint {
51724 if(!isWasmInitialized) {
51725 throw new Error("initializeWasm() must be awaited first!");
51727 const nativeResponseValue = wasm.TS_CoinSelection_clone(orig);
51728 return nativeResponseValue;
51730 // void CoinSelectionSource_free(struct LDKCoinSelectionSource this_ptr);
51732 export function CoinSelectionSource_free(this_ptr: bigint): void {
51733 if(!isWasmInitialized) {
51734 throw new Error("initializeWasm() must be awaited first!");
51736 const nativeResponseValue = wasm.TS_CoinSelectionSource_free(this_ptr);
51737 // debug statements here
51739 // void WalletSource_free(struct LDKWalletSource this_ptr);
51741 export function WalletSource_free(this_ptr: bigint): void {
51742 if(!isWasmInitialized) {
51743 throw new Error("initializeWasm() must be awaited first!");
51745 const nativeResponseValue = wasm.TS_WalletSource_free(this_ptr);
51746 // debug statements here
51748 // void Wallet_free(struct LDKWallet this_obj);
51750 export function Wallet_free(this_obj: bigint): void {
51751 if(!isWasmInitialized) {
51752 throw new Error("initializeWasm() must be awaited first!");
51754 const nativeResponseValue = wasm.TS_Wallet_free(this_obj);
51755 // debug statements here
51757 // MUST_USE_RES struct LDKWallet Wallet_new(struct LDKWalletSource source, struct LDKLogger logger);
51759 export function Wallet_new(source: bigint, logger: bigint): bigint {
51760 if(!isWasmInitialized) {
51761 throw new Error("initializeWasm() must be awaited first!");
51763 const nativeResponseValue = wasm.TS_Wallet_new(source, logger);
51764 return nativeResponseValue;
51766 // struct LDKCoinSelectionSource Wallet_as_CoinSelectionSource(const struct LDKWallet *NONNULL_PTR this_arg);
51768 export function Wallet_as_CoinSelectionSource(this_arg: bigint): bigint {
51769 if(!isWasmInitialized) {
51770 throw new Error("initializeWasm() must be awaited first!");
51772 const nativeResponseValue = wasm.TS_Wallet_as_CoinSelectionSource(this_arg);
51773 return nativeResponseValue;
51775 // void BumpTransactionEventHandler_free(struct LDKBumpTransactionEventHandler this_obj);
51777 export function BumpTransactionEventHandler_free(this_obj: bigint): void {
51778 if(!isWasmInitialized) {
51779 throw new Error("initializeWasm() must be awaited first!");
51781 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_free(this_obj);
51782 // debug statements here
51784 // MUST_USE_RES struct LDKBumpTransactionEventHandler BumpTransactionEventHandler_new(struct LDKBroadcasterInterface broadcaster, struct LDKCoinSelectionSource utxo_source, struct LDKSignerProvider signer_provider, struct LDKLogger logger);
51786 export function BumpTransactionEventHandler_new(broadcaster: bigint, utxo_source: bigint, signer_provider: bigint, logger: bigint): bigint {
51787 if(!isWasmInitialized) {
51788 throw new Error("initializeWasm() must be awaited first!");
51790 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_new(broadcaster, utxo_source, signer_provider, logger);
51791 return nativeResponseValue;
51793 // void BumpTransactionEventHandler_handle_event(const struct LDKBumpTransactionEventHandler *NONNULL_PTR this_arg, const struct LDKBumpTransactionEvent *NONNULL_PTR event);
51795 export function BumpTransactionEventHandler_handle_event(this_arg: bigint, event: bigint): void {
51796 if(!isWasmInitialized) {
51797 throw new Error("initializeWasm() must be awaited first!");
51799 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_handle_event(this_arg, event);
51800 // debug statements here
51802 // void GossipSync_free(struct LDKGossipSync this_ptr);
51804 export function GossipSync_free(this_ptr: bigint): void {
51805 if(!isWasmInitialized) {
51806 throw new Error("initializeWasm() must be awaited first!");
51808 const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
51809 // debug statements here
51811 // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
51813 export function GossipSync_p2_p(a: bigint): bigint {
51814 if(!isWasmInitialized) {
51815 throw new Error("initializeWasm() must be awaited first!");
51817 const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
51818 return nativeResponseValue;
51820 // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
51822 export function GossipSync_rapid(a: bigint): bigint {
51823 if(!isWasmInitialized) {
51824 throw new Error("initializeWasm() must be awaited first!");
51826 const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
51827 return nativeResponseValue;
51829 // struct LDKGossipSync GossipSync_none(void);
51831 export function GossipSync_none(): bigint {
51832 if(!isWasmInitialized) {
51833 throw new Error("initializeWasm() must be awaited first!");
51835 const nativeResponseValue = wasm.TS_GossipSync_none();
51836 return nativeResponseValue;
51838 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
51840 export function RapidGossipSync_free(this_obj: bigint): void {
51841 if(!isWasmInitialized) {
51842 throw new Error("initializeWasm() must be awaited first!");
51844 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
51845 // debug statements here
51847 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
51849 export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
51850 if(!isWasmInitialized) {
51851 throw new Error("initializeWasm() must be awaited first!");
51853 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
51854 return nativeResponseValue;
51856 // 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);
51858 export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
51859 if(!isWasmInitialized) {
51860 throw new Error("initializeWasm() must be awaited first!");
51862 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
51863 return nativeResponseValue;
51865 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
51867 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
51868 if(!isWasmInitialized) {
51869 throw new Error("initializeWasm() must be awaited first!");
51871 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
51872 return nativeResponseValue;
51874 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
51876 export function GraphSyncError_free(this_ptr: bigint): void {
51877 if(!isWasmInitialized) {
51878 throw new Error("initializeWasm() must be awaited first!");
51880 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
51881 // debug statements here
51883 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
51885 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
51886 if(!isWasmInitialized) {
51887 throw new Error("initializeWasm() must be awaited first!");
51889 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
51890 return nativeResponseValue;
51892 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
51894 export function GraphSyncError_clone(orig: bigint): bigint {
51895 if(!isWasmInitialized) {
51896 throw new Error("initializeWasm() must be awaited first!");
51898 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
51899 return nativeResponseValue;
51901 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
51903 export function GraphSyncError_decode_error(a: bigint): bigint {
51904 if(!isWasmInitialized) {
51905 throw new Error("initializeWasm() must be awaited first!");
51907 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
51908 return nativeResponseValue;
51910 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
51912 export function GraphSyncError_lightning_error(a: bigint): bigint {
51913 if(!isWasmInitialized) {
51914 throw new Error("initializeWasm() must be awaited first!");
51916 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
51917 return nativeResponseValue;
51919 // void Bolt11ParseError_free(struct LDKBolt11ParseError this_ptr);
51921 export function Bolt11ParseError_free(this_ptr: bigint): void {
51922 if(!isWasmInitialized) {
51923 throw new Error("initializeWasm() must be awaited first!");
51925 const nativeResponseValue = wasm.TS_Bolt11ParseError_free(this_ptr);
51926 // debug statements here
51928 // uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg);
51930 export function Bolt11ParseError_clone_ptr(arg: bigint): bigint {
51931 if(!isWasmInitialized) {
51932 throw new Error("initializeWasm() must be awaited first!");
51934 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone_ptr(arg);
51935 return nativeResponseValue;
51937 // struct LDKBolt11ParseError Bolt11ParseError_clone(const struct LDKBolt11ParseError *NONNULL_PTR orig);
51939 export function Bolt11ParseError_clone(orig: bigint): bigint {
51940 if(!isWasmInitialized) {
51941 throw new Error("initializeWasm() must be awaited first!");
51943 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone(orig);
51944 return nativeResponseValue;
51946 // struct LDKBolt11ParseError Bolt11ParseError_bech32_error(struct LDKBech32Error a);
51948 export function Bolt11ParseError_bech32_error(a: bigint): bigint {
51949 if(!isWasmInitialized) {
51950 throw new Error("initializeWasm() must be awaited first!");
51952 const nativeResponseValue = wasm.TS_Bolt11ParseError_bech32_error(a);
51953 return nativeResponseValue;
51955 // struct LDKBolt11ParseError Bolt11ParseError_parse_amount_error(struct LDKError a);
51957 export function Bolt11ParseError_parse_amount_error(a: number): bigint {
51958 if(!isWasmInitialized) {
51959 throw new Error("initializeWasm() must be awaited first!");
51961 const nativeResponseValue = wasm.TS_Bolt11ParseError_parse_amount_error(a);
51962 return nativeResponseValue;
51964 // struct LDKBolt11ParseError Bolt11ParseError_malformed_signature(enum LDKSecp256k1Error a);
51966 export function Bolt11ParseError_malformed_signature(a: Secp256k1Error): bigint {
51967 if(!isWasmInitialized) {
51968 throw new Error("initializeWasm() must be awaited first!");
51970 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_signature(a);
51971 return nativeResponseValue;
51973 // struct LDKBolt11ParseError Bolt11ParseError_bad_prefix(void);
51975 export function Bolt11ParseError_bad_prefix(): bigint {
51976 if(!isWasmInitialized) {
51977 throw new Error("initializeWasm() must be awaited first!");
51979 const nativeResponseValue = wasm.TS_Bolt11ParseError_bad_prefix();
51980 return nativeResponseValue;
51982 // struct LDKBolt11ParseError Bolt11ParseError_unknown_currency(void);
51984 export function Bolt11ParseError_unknown_currency(): bigint {
51985 if(!isWasmInitialized) {
51986 throw new Error("initializeWasm() must be awaited first!");
51988 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_currency();
51989 return nativeResponseValue;
51991 // struct LDKBolt11ParseError Bolt11ParseError_unknown_si_prefix(void);
51993 export function Bolt11ParseError_unknown_si_prefix(): bigint {
51994 if(!isWasmInitialized) {
51995 throw new Error("initializeWasm() must be awaited first!");
51997 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_si_prefix();
51998 return nativeResponseValue;
52000 // struct LDKBolt11ParseError Bolt11ParseError_malformed_hrp(void);
52002 export function Bolt11ParseError_malformed_hrp(): bigint {
52003 if(!isWasmInitialized) {
52004 throw new Error("initializeWasm() must be awaited first!");
52006 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_hrp();
52007 return nativeResponseValue;
52009 // struct LDKBolt11ParseError Bolt11ParseError_too_short_data_part(void);
52011 export function Bolt11ParseError_too_short_data_part(): bigint {
52012 if(!isWasmInitialized) {
52013 throw new Error("initializeWasm() must be awaited first!");
52015 const nativeResponseValue = wasm.TS_Bolt11ParseError_too_short_data_part();
52016 return nativeResponseValue;
52018 // struct LDKBolt11ParseError Bolt11ParseError_unexpected_end_of_tagged_fields(void);
52020 export function Bolt11ParseError_unexpected_end_of_tagged_fields(): bigint {
52021 if(!isWasmInitialized) {
52022 throw new Error("initializeWasm() must be awaited first!");
52024 const nativeResponseValue = wasm.TS_Bolt11ParseError_unexpected_end_of_tagged_fields();
52025 return nativeResponseValue;
52027 // struct LDKBolt11ParseError Bolt11ParseError_description_decode_error(struct LDKError a);
52029 export function Bolt11ParseError_description_decode_error(a: number): bigint {
52030 if(!isWasmInitialized) {
52031 throw new Error("initializeWasm() must be awaited first!");
52033 const nativeResponseValue = wasm.TS_Bolt11ParseError_description_decode_error(a);
52034 return nativeResponseValue;
52036 // struct LDKBolt11ParseError Bolt11ParseError_padding_error(void);
52038 export function Bolt11ParseError_padding_error(): bigint {
52039 if(!isWasmInitialized) {
52040 throw new Error("initializeWasm() must be awaited first!");
52042 const nativeResponseValue = wasm.TS_Bolt11ParseError_padding_error();
52043 return nativeResponseValue;
52045 // struct LDKBolt11ParseError Bolt11ParseError_integer_overflow_error(void);
52047 export function Bolt11ParseError_integer_overflow_error(): bigint {
52048 if(!isWasmInitialized) {
52049 throw new Error("initializeWasm() must be awaited first!");
52051 const nativeResponseValue = wasm.TS_Bolt11ParseError_integer_overflow_error();
52052 return nativeResponseValue;
52054 // struct LDKBolt11ParseError Bolt11ParseError_invalid_seg_wit_program_length(void);
52056 export function Bolt11ParseError_invalid_seg_wit_program_length(): bigint {
52057 if(!isWasmInitialized) {
52058 throw new Error("initializeWasm() must be awaited first!");
52060 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_seg_wit_program_length();
52061 return nativeResponseValue;
52063 // struct LDKBolt11ParseError Bolt11ParseError_invalid_pub_key_hash_length(void);
52065 export function Bolt11ParseError_invalid_pub_key_hash_length(): bigint {
52066 if(!isWasmInitialized) {
52067 throw new Error("initializeWasm() must be awaited first!");
52069 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_pub_key_hash_length();
52070 return nativeResponseValue;
52072 // struct LDKBolt11ParseError Bolt11ParseError_invalid_script_hash_length(void);
52074 export function Bolt11ParseError_invalid_script_hash_length(): bigint {
52075 if(!isWasmInitialized) {
52076 throw new Error("initializeWasm() must be awaited first!");
52078 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_script_hash_length();
52079 return nativeResponseValue;
52081 // struct LDKBolt11ParseError Bolt11ParseError_invalid_recovery_id(void);
52083 export function Bolt11ParseError_invalid_recovery_id(): bigint {
52084 if(!isWasmInitialized) {
52085 throw new Error("initializeWasm() must be awaited first!");
52087 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_recovery_id();
52088 return nativeResponseValue;
52090 // struct LDKBolt11ParseError Bolt11ParseError_invalid_slice_length(struct LDKStr a);
52092 export function Bolt11ParseError_invalid_slice_length(a: number): bigint {
52093 if(!isWasmInitialized) {
52094 throw new Error("initializeWasm() must be awaited first!");
52096 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_slice_length(a);
52097 return nativeResponseValue;
52099 // struct LDKBolt11ParseError Bolt11ParseError_skip(void);
52101 export function Bolt11ParseError_skip(): bigint {
52102 if(!isWasmInitialized) {
52103 throw new Error("initializeWasm() must be awaited first!");
52105 const nativeResponseValue = wasm.TS_Bolt11ParseError_skip();
52106 return nativeResponseValue;
52108 // bool Bolt11ParseError_eq(const struct LDKBolt11ParseError *NONNULL_PTR a, const struct LDKBolt11ParseError *NONNULL_PTR b);
52110 export function Bolt11ParseError_eq(a: bigint, b: bigint): boolean {
52111 if(!isWasmInitialized) {
52112 throw new Error("initializeWasm() must be awaited first!");
52114 const nativeResponseValue = wasm.TS_Bolt11ParseError_eq(a, b);
52115 return nativeResponseValue;
52117 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
52119 export function ParseOrSemanticError_free(this_ptr: bigint): void {
52120 if(!isWasmInitialized) {
52121 throw new Error("initializeWasm() must be awaited first!");
52123 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
52124 // debug statements here
52126 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
52128 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
52129 if(!isWasmInitialized) {
52130 throw new Error("initializeWasm() must be awaited first!");
52132 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
52133 return nativeResponseValue;
52135 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
52137 export function ParseOrSemanticError_clone(orig: bigint): bigint {
52138 if(!isWasmInitialized) {
52139 throw new Error("initializeWasm() must be awaited first!");
52141 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
52142 return nativeResponseValue;
52144 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKBolt11ParseError a);
52146 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
52147 if(!isWasmInitialized) {
52148 throw new Error("initializeWasm() must be awaited first!");
52150 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
52151 return nativeResponseValue;
52153 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKBolt11SemanticError a);
52155 export function ParseOrSemanticError_semantic_error(a: Bolt11SemanticError): bigint {
52156 if(!isWasmInitialized) {
52157 throw new Error("initializeWasm() must be awaited first!");
52159 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
52160 return nativeResponseValue;
52162 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
52164 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
52165 if(!isWasmInitialized) {
52166 throw new Error("initializeWasm() must be awaited first!");
52168 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
52169 return nativeResponseValue;
52171 // void Bolt11Invoice_free(struct LDKBolt11Invoice this_obj);
52173 export function Bolt11Invoice_free(this_obj: bigint): void {
52174 if(!isWasmInitialized) {
52175 throw new Error("initializeWasm() must be awaited first!");
52177 const nativeResponseValue = wasm.TS_Bolt11Invoice_free(this_obj);
52178 // debug statements here
52180 // bool Bolt11Invoice_eq(const struct LDKBolt11Invoice *NONNULL_PTR a, const struct LDKBolt11Invoice *NONNULL_PTR b);
52182 export function Bolt11Invoice_eq(a: bigint, b: bigint): boolean {
52183 if(!isWasmInitialized) {
52184 throw new Error("initializeWasm() must be awaited first!");
52186 const nativeResponseValue = wasm.TS_Bolt11Invoice_eq(a, b);
52187 return nativeResponseValue;
52189 // uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg);
52191 export function Bolt11Invoice_clone_ptr(arg: bigint): bigint {
52192 if(!isWasmInitialized) {
52193 throw new Error("initializeWasm() must be awaited first!");
52195 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone_ptr(arg);
52196 return nativeResponseValue;
52198 // struct LDKBolt11Invoice Bolt11Invoice_clone(const struct LDKBolt11Invoice *NONNULL_PTR orig);
52200 export function Bolt11Invoice_clone(orig: bigint): bigint {
52201 if(!isWasmInitialized) {
52202 throw new Error("initializeWasm() must be awaited first!");
52204 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone(orig);
52205 return nativeResponseValue;
52207 // uint64_t Bolt11Invoice_hash(const struct LDKBolt11Invoice *NONNULL_PTR o);
52209 export function Bolt11Invoice_hash(o: bigint): bigint {
52210 if(!isWasmInitialized) {
52211 throw new Error("initializeWasm() must be awaited first!");
52213 const nativeResponseValue = wasm.TS_Bolt11Invoice_hash(o);
52214 return nativeResponseValue;
52216 // void SignedRawBolt11Invoice_free(struct LDKSignedRawBolt11Invoice this_obj);
52218 export function SignedRawBolt11Invoice_free(this_obj: bigint): void {
52219 if(!isWasmInitialized) {
52220 throw new Error("initializeWasm() must be awaited first!");
52222 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_free(this_obj);
52223 // debug statements here
52225 // bool SignedRawBolt11Invoice_eq(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR a, const struct LDKSignedRawBolt11Invoice *NONNULL_PTR b);
52227 export function SignedRawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
52228 if(!isWasmInitialized) {
52229 throw new Error("initializeWasm() must be awaited first!");
52231 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_eq(a, b);
52232 return nativeResponseValue;
52234 // uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg);
52236 export function SignedRawBolt11Invoice_clone_ptr(arg: bigint): bigint {
52237 if(!isWasmInitialized) {
52238 throw new Error("initializeWasm() must be awaited first!");
52240 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone_ptr(arg);
52241 return nativeResponseValue;
52243 // struct LDKSignedRawBolt11Invoice SignedRawBolt11Invoice_clone(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR orig);
52245 export function SignedRawBolt11Invoice_clone(orig: bigint): bigint {
52246 if(!isWasmInitialized) {
52247 throw new Error("initializeWasm() must be awaited first!");
52249 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone(orig);
52250 return nativeResponseValue;
52252 // uint64_t SignedRawBolt11Invoice_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
52254 export function SignedRawBolt11Invoice_hash(o: bigint): bigint {
52255 if(!isWasmInitialized) {
52256 throw new Error("initializeWasm() must be awaited first!");
52258 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_hash(o);
52259 return nativeResponseValue;
52261 // void RawBolt11Invoice_free(struct LDKRawBolt11Invoice this_obj);
52263 export function RawBolt11Invoice_free(this_obj: bigint): void {
52264 if(!isWasmInitialized) {
52265 throw new Error("initializeWasm() must be awaited first!");
52267 const nativeResponseValue = wasm.TS_RawBolt11Invoice_free(this_obj);
52268 // debug statements here
52270 // struct LDKRawDataPart RawBolt11Invoice_get_data(const struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr);
52272 export function RawBolt11Invoice_get_data(this_ptr: bigint): bigint {
52273 if(!isWasmInitialized) {
52274 throw new Error("initializeWasm() must be awaited first!");
52276 const nativeResponseValue = wasm.TS_RawBolt11Invoice_get_data(this_ptr);
52277 return nativeResponseValue;
52279 // void RawBolt11Invoice_set_data(struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
52281 export function RawBolt11Invoice_set_data(this_ptr: bigint, val: bigint): void {
52282 if(!isWasmInitialized) {
52283 throw new Error("initializeWasm() must be awaited first!");
52285 const nativeResponseValue = wasm.TS_RawBolt11Invoice_set_data(this_ptr, val);
52286 // debug statements here
52288 // bool RawBolt11Invoice_eq(const struct LDKRawBolt11Invoice *NONNULL_PTR a, const struct LDKRawBolt11Invoice *NONNULL_PTR b);
52290 export function RawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
52291 if(!isWasmInitialized) {
52292 throw new Error("initializeWasm() must be awaited first!");
52294 const nativeResponseValue = wasm.TS_RawBolt11Invoice_eq(a, b);
52295 return nativeResponseValue;
52297 // uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg);
52299 export function RawBolt11Invoice_clone_ptr(arg: bigint): bigint {
52300 if(!isWasmInitialized) {
52301 throw new Error("initializeWasm() must be awaited first!");
52303 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone_ptr(arg);
52304 return nativeResponseValue;
52306 // struct LDKRawBolt11Invoice RawBolt11Invoice_clone(const struct LDKRawBolt11Invoice *NONNULL_PTR orig);
52308 export function RawBolt11Invoice_clone(orig: bigint): bigint {
52309 if(!isWasmInitialized) {
52310 throw new Error("initializeWasm() must be awaited first!");
52312 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone(orig);
52313 return nativeResponseValue;
52315 // uint64_t RawBolt11Invoice_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR o);
52317 export function RawBolt11Invoice_hash(o: bigint): bigint {
52318 if(!isWasmInitialized) {
52319 throw new Error("initializeWasm() must be awaited first!");
52321 const nativeResponseValue = wasm.TS_RawBolt11Invoice_hash(o);
52322 return nativeResponseValue;
52324 // void RawDataPart_free(struct LDKRawDataPart this_obj);
52326 export function RawDataPart_free(this_obj: bigint): void {
52327 if(!isWasmInitialized) {
52328 throw new Error("initializeWasm() must be awaited first!");
52330 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
52331 // debug statements here
52333 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
52335 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
52336 if(!isWasmInitialized) {
52337 throw new Error("initializeWasm() must be awaited first!");
52339 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
52340 return nativeResponseValue;
52342 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
52344 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
52345 if(!isWasmInitialized) {
52346 throw new Error("initializeWasm() must be awaited first!");
52348 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
52349 // debug statements here
52351 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
52353 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
52354 if(!isWasmInitialized) {
52355 throw new Error("initializeWasm() must be awaited first!");
52357 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
52358 return nativeResponseValue;
52360 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
52362 export function RawDataPart_clone_ptr(arg: bigint): bigint {
52363 if(!isWasmInitialized) {
52364 throw new Error("initializeWasm() must be awaited first!");
52366 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
52367 return nativeResponseValue;
52369 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
52371 export function RawDataPart_clone(orig: bigint): bigint {
52372 if(!isWasmInitialized) {
52373 throw new Error("initializeWasm() must be awaited first!");
52375 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
52376 return nativeResponseValue;
52378 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
52380 export function RawDataPart_hash(o: bigint): bigint {
52381 if(!isWasmInitialized) {
52382 throw new Error("initializeWasm() must be awaited first!");
52384 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
52385 return nativeResponseValue;
52387 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
52389 export function PositiveTimestamp_free(this_obj: bigint): void {
52390 if(!isWasmInitialized) {
52391 throw new Error("initializeWasm() must be awaited first!");
52393 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
52394 // debug statements here
52396 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
52398 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
52399 if(!isWasmInitialized) {
52400 throw new Error("initializeWasm() must be awaited first!");
52402 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
52403 return nativeResponseValue;
52405 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
52407 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
52408 if(!isWasmInitialized) {
52409 throw new Error("initializeWasm() must be awaited first!");
52411 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
52412 return nativeResponseValue;
52414 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
52416 export function PositiveTimestamp_clone(orig: bigint): bigint {
52417 if(!isWasmInitialized) {
52418 throw new Error("initializeWasm() must be awaited first!");
52420 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
52421 return nativeResponseValue;
52423 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
52425 export function PositiveTimestamp_hash(o: bigint): bigint {
52426 if(!isWasmInitialized) {
52427 throw new Error("initializeWasm() must be awaited first!");
52429 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
52430 return nativeResponseValue;
52432 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
52434 export function SiPrefix_clone(orig: bigint): SiPrefix {
52435 if(!isWasmInitialized) {
52436 throw new Error("initializeWasm() must be awaited first!");
52438 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
52439 return nativeResponseValue;
52441 // enum LDKSiPrefix SiPrefix_milli(void);
52443 export function SiPrefix_milli(): SiPrefix {
52444 if(!isWasmInitialized) {
52445 throw new Error("initializeWasm() must be awaited first!");
52447 const nativeResponseValue = wasm.TS_SiPrefix_milli();
52448 return nativeResponseValue;
52450 // enum LDKSiPrefix SiPrefix_micro(void);
52452 export function SiPrefix_micro(): SiPrefix {
52453 if(!isWasmInitialized) {
52454 throw new Error("initializeWasm() must be awaited first!");
52456 const nativeResponseValue = wasm.TS_SiPrefix_micro();
52457 return nativeResponseValue;
52459 // enum LDKSiPrefix SiPrefix_nano(void);
52461 export function SiPrefix_nano(): SiPrefix {
52462 if(!isWasmInitialized) {
52463 throw new Error("initializeWasm() must be awaited first!");
52465 const nativeResponseValue = wasm.TS_SiPrefix_nano();
52466 return nativeResponseValue;
52468 // enum LDKSiPrefix SiPrefix_pico(void);
52470 export function SiPrefix_pico(): SiPrefix {
52471 if(!isWasmInitialized) {
52472 throw new Error("initializeWasm() must be awaited first!");
52474 const nativeResponseValue = wasm.TS_SiPrefix_pico();
52475 return nativeResponseValue;
52477 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
52479 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
52480 if(!isWasmInitialized) {
52481 throw new Error("initializeWasm() must be awaited first!");
52483 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
52484 return nativeResponseValue;
52486 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
52488 export function SiPrefix_hash(o: bigint): bigint {
52489 if(!isWasmInitialized) {
52490 throw new Error("initializeWasm() must be awaited first!");
52492 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
52493 return nativeResponseValue;
52495 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
52497 export function SiPrefix_multiplier(this_arg: bigint): bigint {
52498 if(!isWasmInitialized) {
52499 throw new Error("initializeWasm() must be awaited first!");
52501 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
52502 return nativeResponseValue;
52504 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
52506 export function Currency_clone(orig: bigint): Currency {
52507 if(!isWasmInitialized) {
52508 throw new Error("initializeWasm() must be awaited first!");
52510 const nativeResponseValue = wasm.TS_Currency_clone(orig);
52511 return nativeResponseValue;
52513 // enum LDKCurrency Currency_bitcoin(void);
52515 export function Currency_bitcoin(): Currency {
52516 if(!isWasmInitialized) {
52517 throw new Error("initializeWasm() must be awaited first!");
52519 const nativeResponseValue = wasm.TS_Currency_bitcoin();
52520 return nativeResponseValue;
52522 // enum LDKCurrency Currency_bitcoin_testnet(void);
52524 export function Currency_bitcoin_testnet(): Currency {
52525 if(!isWasmInitialized) {
52526 throw new Error("initializeWasm() must be awaited first!");
52528 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
52529 return nativeResponseValue;
52531 // enum LDKCurrency Currency_regtest(void);
52533 export function Currency_regtest(): Currency {
52534 if(!isWasmInitialized) {
52535 throw new Error("initializeWasm() must be awaited first!");
52537 const nativeResponseValue = wasm.TS_Currency_regtest();
52538 return nativeResponseValue;
52540 // enum LDKCurrency Currency_simnet(void);
52542 export function Currency_simnet(): Currency {
52543 if(!isWasmInitialized) {
52544 throw new Error("initializeWasm() must be awaited first!");
52546 const nativeResponseValue = wasm.TS_Currency_simnet();
52547 return nativeResponseValue;
52549 // enum LDKCurrency Currency_signet(void);
52551 export function Currency_signet(): Currency {
52552 if(!isWasmInitialized) {
52553 throw new Error("initializeWasm() must be awaited first!");
52555 const nativeResponseValue = wasm.TS_Currency_signet();
52556 return nativeResponseValue;
52558 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
52560 export function Currency_hash(o: bigint): bigint {
52561 if(!isWasmInitialized) {
52562 throw new Error("initializeWasm() must be awaited first!");
52564 const nativeResponseValue = wasm.TS_Currency_hash(o);
52565 return nativeResponseValue;
52567 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
52569 export function Currency_eq(a: bigint, b: bigint): boolean {
52570 if(!isWasmInitialized) {
52571 throw new Error("initializeWasm() must be awaited first!");
52573 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
52574 return nativeResponseValue;
52576 // void Sha256_free(struct LDKSha256 this_obj);
52578 export function Sha256_free(this_obj: bigint): void {
52579 if(!isWasmInitialized) {
52580 throw new Error("initializeWasm() must be awaited first!");
52582 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
52583 // debug statements here
52585 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
52587 export function Sha256_clone_ptr(arg: bigint): bigint {
52588 if(!isWasmInitialized) {
52589 throw new Error("initializeWasm() must be awaited first!");
52591 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
52592 return nativeResponseValue;
52594 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
52596 export function Sha256_clone(orig: bigint): bigint {
52597 if(!isWasmInitialized) {
52598 throw new Error("initializeWasm() must be awaited first!");
52600 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
52601 return nativeResponseValue;
52603 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
52605 export function Sha256_hash(o: bigint): bigint {
52606 if(!isWasmInitialized) {
52607 throw new Error("initializeWasm() must be awaited first!");
52609 const nativeResponseValue = wasm.TS_Sha256_hash(o);
52610 return nativeResponseValue;
52612 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
52614 export function Sha256_eq(a: bigint, b: bigint): boolean {
52615 if(!isWasmInitialized) {
52616 throw new Error("initializeWasm() must be awaited first!");
52618 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
52619 return nativeResponseValue;
52621 // MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
52623 export function Sha256_from_bytes(bytes: number): bigint {
52624 if(!isWasmInitialized) {
52625 throw new Error("initializeWasm() must be awaited first!");
52627 const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
52628 return nativeResponseValue;
52630 // void Description_free(struct LDKDescription this_obj);
52632 export function Description_free(this_obj: bigint): void {
52633 if(!isWasmInitialized) {
52634 throw new Error("initializeWasm() must be awaited first!");
52636 const nativeResponseValue = wasm.TS_Description_free(this_obj);
52637 // debug statements here
52639 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
52641 export function Description_clone_ptr(arg: bigint): bigint {
52642 if(!isWasmInitialized) {
52643 throw new Error("initializeWasm() must be awaited first!");
52645 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
52646 return nativeResponseValue;
52648 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
52650 export function Description_clone(orig: bigint): bigint {
52651 if(!isWasmInitialized) {
52652 throw new Error("initializeWasm() must be awaited first!");
52654 const nativeResponseValue = wasm.TS_Description_clone(orig);
52655 return nativeResponseValue;
52657 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
52659 export function Description_hash(o: bigint): bigint {
52660 if(!isWasmInitialized) {
52661 throw new Error("initializeWasm() must be awaited first!");
52663 const nativeResponseValue = wasm.TS_Description_hash(o);
52664 return nativeResponseValue;
52666 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
52668 export function Description_eq(a: bigint, b: bigint): boolean {
52669 if(!isWasmInitialized) {
52670 throw new Error("initializeWasm() must be awaited first!");
52672 const nativeResponseValue = wasm.TS_Description_eq(a, b);
52673 return nativeResponseValue;
52675 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
52677 export function PayeePubKey_free(this_obj: bigint): void {
52678 if(!isWasmInitialized) {
52679 throw new Error("initializeWasm() must be awaited first!");
52681 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
52682 // debug statements here
52684 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
52686 export function PayeePubKey_get_a(this_ptr: bigint): number {
52687 if(!isWasmInitialized) {
52688 throw new Error("initializeWasm() must be awaited first!");
52690 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
52691 return nativeResponseValue;
52693 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
52695 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
52696 if(!isWasmInitialized) {
52697 throw new Error("initializeWasm() must be awaited first!");
52699 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
52700 // debug statements here
52702 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
52704 export function PayeePubKey_new(a_arg: number): bigint {
52705 if(!isWasmInitialized) {
52706 throw new Error("initializeWasm() must be awaited first!");
52708 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
52709 return nativeResponseValue;
52711 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
52713 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
52714 if(!isWasmInitialized) {
52715 throw new Error("initializeWasm() must be awaited first!");
52717 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
52718 return nativeResponseValue;
52720 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
52722 export function PayeePubKey_clone(orig: bigint): bigint {
52723 if(!isWasmInitialized) {
52724 throw new Error("initializeWasm() must be awaited first!");
52726 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
52727 return nativeResponseValue;
52729 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
52731 export function PayeePubKey_hash(o: bigint): bigint {
52732 if(!isWasmInitialized) {
52733 throw new Error("initializeWasm() must be awaited first!");
52735 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
52736 return nativeResponseValue;
52738 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
52740 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
52741 if(!isWasmInitialized) {
52742 throw new Error("initializeWasm() must be awaited first!");
52744 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
52745 return nativeResponseValue;
52747 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
52749 export function ExpiryTime_free(this_obj: bigint): void {
52750 if(!isWasmInitialized) {
52751 throw new Error("initializeWasm() must be awaited first!");
52753 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
52754 // debug statements here
52756 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
52758 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
52759 if(!isWasmInitialized) {
52760 throw new Error("initializeWasm() must be awaited first!");
52762 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
52763 return nativeResponseValue;
52765 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
52767 export function ExpiryTime_clone(orig: bigint): bigint {
52768 if(!isWasmInitialized) {
52769 throw new Error("initializeWasm() must be awaited first!");
52771 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
52772 return nativeResponseValue;
52774 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
52776 export function ExpiryTime_hash(o: bigint): bigint {
52777 if(!isWasmInitialized) {
52778 throw new Error("initializeWasm() must be awaited first!");
52780 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
52781 return nativeResponseValue;
52783 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
52785 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
52786 if(!isWasmInitialized) {
52787 throw new Error("initializeWasm() must be awaited first!");
52789 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
52790 return nativeResponseValue;
52792 // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
52794 export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
52795 if(!isWasmInitialized) {
52796 throw new Error("initializeWasm() must be awaited first!");
52798 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
52799 // debug statements here
52801 // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
52803 export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
52804 if(!isWasmInitialized) {
52805 throw new Error("initializeWasm() must be awaited first!");
52807 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
52808 return nativeResponseValue;
52810 // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
52812 export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
52813 if(!isWasmInitialized) {
52814 throw new Error("initializeWasm() must be awaited first!");
52816 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
52817 // debug statements here
52819 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
52821 export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
52822 if(!isWasmInitialized) {
52823 throw new Error("initializeWasm() must be awaited first!");
52825 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
52826 return nativeResponseValue;
52828 // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
52830 export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
52831 if(!isWasmInitialized) {
52832 throw new Error("initializeWasm() must be awaited first!");
52834 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
52835 return nativeResponseValue;
52837 // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
52839 export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
52840 if(!isWasmInitialized) {
52841 throw new Error("initializeWasm() must be awaited first!");
52843 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
52844 return nativeResponseValue;
52846 // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
52848 export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
52849 if(!isWasmInitialized) {
52850 throw new Error("initializeWasm() must be awaited first!");
52852 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
52853 return nativeResponseValue;
52855 // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
52857 export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
52858 if(!isWasmInitialized) {
52859 throw new Error("initializeWasm() must be awaited first!");
52861 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
52862 return nativeResponseValue;
52864 // void Fallback_free(struct LDKFallback this_ptr);
52866 export function Fallback_free(this_ptr: bigint): void {
52867 if(!isWasmInitialized) {
52868 throw new Error("initializeWasm() must be awaited first!");
52870 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
52871 // debug statements here
52873 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
52875 export function Fallback_clone_ptr(arg: bigint): bigint {
52876 if(!isWasmInitialized) {
52877 throw new Error("initializeWasm() must be awaited first!");
52879 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
52880 return nativeResponseValue;
52882 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
52884 export function Fallback_clone(orig: bigint): bigint {
52885 if(!isWasmInitialized) {
52886 throw new Error("initializeWasm() must be awaited first!");
52888 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
52889 return nativeResponseValue;
52891 // struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
52893 export function Fallback_seg_wit_program(version: number, program: number): bigint {
52894 if(!isWasmInitialized) {
52895 throw new Error("initializeWasm() must be awaited first!");
52897 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
52898 return nativeResponseValue;
52900 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
52902 export function Fallback_pub_key_hash(a: number): bigint {
52903 if(!isWasmInitialized) {
52904 throw new Error("initializeWasm() must be awaited first!");
52906 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
52907 return nativeResponseValue;
52909 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
52911 export function Fallback_script_hash(a: number): bigint {
52912 if(!isWasmInitialized) {
52913 throw new Error("initializeWasm() must be awaited first!");
52915 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
52916 return nativeResponseValue;
52918 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
52920 export function Fallback_hash(o: bigint): bigint {
52921 if(!isWasmInitialized) {
52922 throw new Error("initializeWasm() must be awaited first!");
52924 const nativeResponseValue = wasm.TS_Fallback_hash(o);
52925 return nativeResponseValue;
52927 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
52929 export function Fallback_eq(a: bigint, b: bigint): boolean {
52930 if(!isWasmInitialized) {
52931 throw new Error("initializeWasm() must be awaited first!");
52933 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
52934 return nativeResponseValue;
52936 // void Bolt11InvoiceSignature_free(struct LDKBolt11InvoiceSignature this_obj);
52938 export function Bolt11InvoiceSignature_free(this_obj: bigint): void {
52939 if(!isWasmInitialized) {
52940 throw new Error("initializeWasm() must be awaited first!");
52942 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_free(this_obj);
52943 // debug statements here
52945 // uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg);
52947 export function Bolt11InvoiceSignature_clone_ptr(arg: bigint): bigint {
52948 if(!isWasmInitialized) {
52949 throw new Error("initializeWasm() must be awaited first!");
52951 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone_ptr(arg);
52952 return nativeResponseValue;
52954 // struct LDKBolt11InvoiceSignature Bolt11InvoiceSignature_clone(const struct LDKBolt11InvoiceSignature *NONNULL_PTR orig);
52956 export function Bolt11InvoiceSignature_clone(orig: bigint): bigint {
52957 if(!isWasmInitialized) {
52958 throw new Error("initializeWasm() must be awaited first!");
52960 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone(orig);
52961 return nativeResponseValue;
52963 // uint64_t Bolt11InvoiceSignature_hash(const struct LDKBolt11InvoiceSignature *NONNULL_PTR o);
52965 export function Bolt11InvoiceSignature_hash(o: bigint): bigint {
52966 if(!isWasmInitialized) {
52967 throw new Error("initializeWasm() must be awaited first!");
52969 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_hash(o);
52970 return nativeResponseValue;
52972 // bool Bolt11InvoiceSignature_eq(const struct LDKBolt11InvoiceSignature *NONNULL_PTR a, const struct LDKBolt11InvoiceSignature *NONNULL_PTR b);
52974 export function Bolt11InvoiceSignature_eq(a: bigint, b: bigint): boolean {
52975 if(!isWasmInitialized) {
52976 throw new Error("initializeWasm() must be awaited first!");
52978 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_eq(a, b);
52979 return nativeResponseValue;
52981 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
52983 export function PrivateRoute_free(this_obj: bigint): void {
52984 if(!isWasmInitialized) {
52985 throw new Error("initializeWasm() must be awaited first!");
52987 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
52988 // debug statements here
52990 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
52992 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
52993 if(!isWasmInitialized) {
52994 throw new Error("initializeWasm() must be awaited first!");
52996 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
52997 return nativeResponseValue;
52999 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
53001 export function PrivateRoute_clone(orig: bigint): bigint {
53002 if(!isWasmInitialized) {
53003 throw new Error("initializeWasm() must be awaited first!");
53005 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
53006 return nativeResponseValue;
53008 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
53010 export function PrivateRoute_hash(o: bigint): bigint {
53011 if(!isWasmInitialized) {
53012 throw new Error("initializeWasm() must be awaited first!");
53014 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
53015 return nativeResponseValue;
53017 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
53019 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
53020 if(!isWasmInitialized) {
53021 throw new Error("initializeWasm() must be awaited first!");
53023 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
53024 return nativeResponseValue;
53026 // MUST_USE_RES struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ SignedRawBolt11Invoice_into_parts(struct LDKSignedRawBolt11Invoice this_arg);
53028 export function SignedRawBolt11Invoice_into_parts(this_arg: bigint): bigint {
53029 if(!isWasmInitialized) {
53030 throw new Error("initializeWasm() must be awaited first!");
53032 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_into_parts(this_arg);
53033 return nativeResponseValue;
53035 // MUST_USE_RES struct LDKRawBolt11Invoice SignedRawBolt11Invoice_raw_invoice(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53037 export function SignedRawBolt11Invoice_raw_invoice(this_arg: bigint): bigint {
53038 if(!isWasmInitialized) {
53039 throw new Error("initializeWasm() must be awaited first!");
53041 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_raw_invoice(this_arg);
53042 return nativeResponseValue;
53044 // MUST_USE_RES const uint8_t (*SignedRawBolt11Invoice_signable_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg))[32];
53046 export function SignedRawBolt11Invoice_signable_hash(this_arg: bigint): number {
53047 if(!isWasmInitialized) {
53048 throw new Error("initializeWasm() must be awaited first!");
53050 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signable_hash(this_arg);
53051 return nativeResponseValue;
53053 // MUST_USE_RES struct LDKBolt11InvoiceSignature SignedRawBolt11Invoice_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53055 export function SignedRawBolt11Invoice_signature(this_arg: bigint): bigint {
53056 if(!isWasmInitialized) {
53057 throw new Error("initializeWasm() must be awaited first!");
53059 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signature(this_arg);
53060 return nativeResponseValue;
53062 // MUST_USE_RES struct LDKCResult_PayeePubKeySecp256k1ErrorZ SignedRawBolt11Invoice_recover_payee_pub_key(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53064 export function SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: bigint): bigint {
53065 if(!isWasmInitialized) {
53066 throw new Error("initializeWasm() must be awaited first!");
53068 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_recover_payee_pub_key(this_arg);
53069 return nativeResponseValue;
53071 // MUST_USE_RES bool SignedRawBolt11Invoice_check_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53073 export function SignedRawBolt11Invoice_check_signature(this_arg: bigint): boolean {
53074 if(!isWasmInitialized) {
53075 throw new Error("initializeWasm() must be awaited first!");
53077 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_check_signature(this_arg);
53078 return nativeResponseValue;
53080 // MUST_USE_RES struct LDKThirtyTwoBytes RawBolt11Invoice_signable_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53082 export function RawBolt11Invoice_signable_hash(this_arg: bigint): number {
53083 if(!isWasmInitialized) {
53084 throw new Error("initializeWasm() must be awaited first!");
53086 const nativeResponseValue = wasm.TS_RawBolt11Invoice_signable_hash(this_arg);
53087 return nativeResponseValue;
53089 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_payment_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53091 export function RawBolt11Invoice_payment_hash(this_arg: bigint): bigint {
53092 if(!isWasmInitialized) {
53093 throw new Error("initializeWasm() must be awaited first!");
53095 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_hash(this_arg);
53096 return nativeResponseValue;
53098 // MUST_USE_RES struct LDKDescription RawBolt11Invoice_description(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53100 export function RawBolt11Invoice_description(this_arg: bigint): bigint {
53101 if(!isWasmInitialized) {
53102 throw new Error("initializeWasm() must be awaited first!");
53104 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description(this_arg);
53105 return nativeResponseValue;
53107 // MUST_USE_RES struct LDKPayeePubKey RawBolt11Invoice_payee_pub_key(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53109 export function RawBolt11Invoice_payee_pub_key(this_arg: bigint): bigint {
53110 if(!isWasmInitialized) {
53111 throw new Error("initializeWasm() must be awaited first!");
53113 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payee_pub_key(this_arg);
53114 return nativeResponseValue;
53116 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_description_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53118 export function RawBolt11Invoice_description_hash(this_arg: bigint): bigint {
53119 if(!isWasmInitialized) {
53120 throw new Error("initializeWasm() must be awaited first!");
53122 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description_hash(this_arg);
53123 return nativeResponseValue;
53125 // MUST_USE_RES struct LDKExpiryTime RawBolt11Invoice_expiry_time(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53127 export function RawBolt11Invoice_expiry_time(this_arg: bigint): bigint {
53128 if(!isWasmInitialized) {
53129 throw new Error("initializeWasm() must be awaited first!");
53131 const nativeResponseValue = wasm.TS_RawBolt11Invoice_expiry_time(this_arg);
53132 return nativeResponseValue;
53134 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawBolt11Invoice_min_final_cltv_expiry_delta(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53136 export function RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
53137 if(!isWasmInitialized) {
53138 throw new Error("initializeWasm() must be awaited first!");
53140 const nativeResponseValue = wasm.TS_RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg);
53141 return nativeResponseValue;
53143 // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ RawBolt11Invoice_payment_secret(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53145 export function RawBolt11Invoice_payment_secret(this_arg: bigint): bigint {
53146 if(!isWasmInitialized) {
53147 throw new Error("initializeWasm() must be awaited first!");
53149 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_secret(this_arg);
53150 return nativeResponseValue;
53152 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawBolt11Invoice_payment_metadata(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53154 export function RawBolt11Invoice_payment_metadata(this_arg: bigint): bigint {
53155 if(!isWasmInitialized) {
53156 throw new Error("initializeWasm() must be awaited first!");
53158 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_metadata(this_arg);
53159 return nativeResponseValue;
53161 // MUST_USE_RES struct LDKBolt11InvoiceFeatures RawBolt11Invoice_features(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53163 export function RawBolt11Invoice_features(this_arg: bigint): bigint {
53164 if(!isWasmInitialized) {
53165 throw new Error("initializeWasm() must be awaited first!");
53167 const nativeResponseValue = wasm.TS_RawBolt11Invoice_features(this_arg);
53168 return nativeResponseValue;
53170 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawBolt11Invoice_private_routes(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53172 export function RawBolt11Invoice_private_routes(this_arg: bigint): number {
53173 if(!isWasmInitialized) {
53174 throw new Error("initializeWasm() must be awaited first!");
53176 const nativeResponseValue = wasm.TS_RawBolt11Invoice_private_routes(this_arg);
53177 return nativeResponseValue;
53179 // MUST_USE_RES struct LDKCOption_u64Z RawBolt11Invoice_amount_pico_btc(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53181 export function RawBolt11Invoice_amount_pico_btc(this_arg: bigint): bigint {
53182 if(!isWasmInitialized) {
53183 throw new Error("initializeWasm() must be awaited first!");
53185 const nativeResponseValue = wasm.TS_RawBolt11Invoice_amount_pico_btc(this_arg);
53186 return nativeResponseValue;
53188 // MUST_USE_RES enum LDKCurrency RawBolt11Invoice_currency(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53190 export function RawBolt11Invoice_currency(this_arg: bigint): Currency {
53191 if(!isWasmInitialized) {
53192 throw new Error("initializeWasm() must be awaited first!");
53194 const nativeResponseValue = wasm.TS_RawBolt11Invoice_currency(this_arg);
53195 return nativeResponseValue;
53197 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
53199 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
53200 if(!isWasmInitialized) {
53201 throw new Error("initializeWasm() must be awaited first!");
53203 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
53204 return nativeResponseValue;
53206 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
53208 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
53209 if(!isWasmInitialized) {
53210 throw new Error("initializeWasm() must be awaited first!");
53212 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
53213 return nativeResponseValue;
53215 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
53217 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
53218 if(!isWasmInitialized) {
53219 throw new Error("initializeWasm() must be awaited first!");
53221 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
53222 return nativeResponseValue;
53224 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
53226 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
53227 if(!isWasmInitialized) {
53228 throw new Error("initializeWasm() must be awaited first!");
53230 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
53231 return nativeResponseValue;
53233 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt11Invoice_signable_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53235 export function Bolt11Invoice_signable_hash(this_arg: bigint): number {
53236 if(!isWasmInitialized) {
53237 throw new Error("initializeWasm() must be awaited first!");
53239 const nativeResponseValue = wasm.TS_Bolt11Invoice_signable_hash(this_arg);
53240 return nativeResponseValue;
53242 // MUST_USE_RES struct LDKSignedRawBolt11Invoice Bolt11Invoice_into_signed_raw(struct LDKBolt11Invoice this_arg);
53244 export function Bolt11Invoice_into_signed_raw(this_arg: bigint): bigint {
53245 if(!isWasmInitialized) {
53246 throw new Error("initializeWasm() must be awaited first!");
53248 const nativeResponseValue = wasm.TS_Bolt11Invoice_into_signed_raw(this_arg);
53249 return nativeResponseValue;
53251 // MUST_USE_RES struct LDKCResult_NoneBolt11SemanticErrorZ Bolt11Invoice_check_signature(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53253 export function Bolt11Invoice_check_signature(this_arg: bigint): bigint {
53254 if(!isWasmInitialized) {
53255 throw new Error("initializeWasm() must be awaited first!");
53257 const nativeResponseValue = wasm.TS_Bolt11Invoice_check_signature(this_arg);
53258 return nativeResponseValue;
53260 // MUST_USE_RES struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ Bolt11Invoice_from_signed(struct LDKSignedRawBolt11Invoice signed_invoice);
53262 export function Bolt11Invoice_from_signed(signed_invoice: bigint): bigint {
53263 if(!isWasmInitialized) {
53264 throw new Error("initializeWasm() must be awaited first!");
53266 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_signed(signed_invoice);
53267 return nativeResponseValue;
53269 // MUST_USE_RES uint64_t Bolt11Invoice_duration_since_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53271 export function Bolt11Invoice_duration_since_epoch(this_arg: bigint): bigint {
53272 if(!isWasmInitialized) {
53273 throw new Error("initializeWasm() must be awaited first!");
53275 const nativeResponseValue = wasm.TS_Bolt11Invoice_duration_since_epoch(this_arg);
53276 return nativeResponseValue;
53278 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
53280 export function Bolt11Invoice_payment_hash(this_arg: bigint): number {
53281 if(!isWasmInitialized) {
53282 throw new Error("initializeWasm() must be awaited first!");
53284 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_hash(this_arg);
53285 return nativeResponseValue;
53287 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53289 export function Bolt11Invoice_payee_pub_key(this_arg: bigint): number {
53290 if(!isWasmInitialized) {
53291 throw new Error("initializeWasm() must be awaited first!");
53293 const nativeResponseValue = wasm.TS_Bolt11Invoice_payee_pub_key(this_arg);
53294 return nativeResponseValue;
53296 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_secret(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
53298 export function Bolt11Invoice_payment_secret(this_arg: bigint): number {
53299 if(!isWasmInitialized) {
53300 throw new Error("initializeWasm() must be awaited first!");
53302 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_secret(this_arg);
53303 return nativeResponseValue;
53305 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt11Invoice_payment_metadata(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53307 export function Bolt11Invoice_payment_metadata(this_arg: bigint): bigint {
53308 if(!isWasmInitialized) {
53309 throw new Error("initializeWasm() must be awaited first!");
53311 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_metadata(this_arg);
53312 return nativeResponseValue;
53314 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11Invoice_features(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53316 export function Bolt11Invoice_features(this_arg: bigint): bigint {
53317 if(!isWasmInitialized) {
53318 throw new Error("initializeWasm() must be awaited first!");
53320 const nativeResponseValue = wasm.TS_Bolt11Invoice_features(this_arg);
53321 return nativeResponseValue;
53323 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_recover_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53325 export function Bolt11Invoice_recover_payee_pub_key(this_arg: bigint): number {
53326 if(!isWasmInitialized) {
53327 throw new Error("initializeWasm() must be awaited first!");
53329 const nativeResponseValue = wasm.TS_Bolt11Invoice_recover_payee_pub_key(this_arg);
53330 return nativeResponseValue;
53332 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_expires_at(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53334 export function Bolt11Invoice_expires_at(this_arg: bigint): bigint {
53335 if(!isWasmInitialized) {
53336 throw new Error("initializeWasm() must be awaited first!");
53338 const nativeResponseValue = wasm.TS_Bolt11Invoice_expires_at(this_arg);
53339 return nativeResponseValue;
53341 // MUST_USE_RES uint64_t Bolt11Invoice_expiry_time(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53343 export function Bolt11Invoice_expiry_time(this_arg: bigint): bigint {
53344 if(!isWasmInitialized) {
53345 throw new Error("initializeWasm() must be awaited first!");
53347 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiry_time(this_arg);
53348 return nativeResponseValue;
53350 // MUST_USE_RES uint64_t Bolt11Invoice_expiration_remaining_from_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t time);
53352 export function Bolt11Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
53353 if(!isWasmInitialized) {
53354 throw new Error("initializeWasm() must be awaited first!");
53356 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiration_remaining_from_epoch(this_arg, time);
53357 return nativeResponseValue;
53359 // MUST_USE_RES bool Bolt11Invoice_would_expire(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t at_time);
53361 export function Bolt11Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
53362 if(!isWasmInitialized) {
53363 throw new Error("initializeWasm() must be awaited first!");
53365 const nativeResponseValue = wasm.TS_Bolt11Invoice_would_expire(this_arg, at_time);
53366 return nativeResponseValue;
53368 // MUST_USE_RES uint64_t Bolt11Invoice_min_final_cltv_expiry_delta(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53370 export function Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
53371 if(!isWasmInitialized) {
53372 throw new Error("initializeWasm() must be awaited first!");
53374 const nativeResponseValue = wasm.TS_Bolt11Invoice_min_final_cltv_expiry_delta(this_arg);
53375 return nativeResponseValue;
53377 // MUST_USE_RES struct LDKCVec_StrZ Bolt11Invoice_fallback_addresses(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53379 export function Bolt11Invoice_fallback_addresses(this_arg: bigint): number {
53380 if(!isWasmInitialized) {
53381 throw new Error("initializeWasm() must be awaited first!");
53383 const nativeResponseValue = wasm.TS_Bolt11Invoice_fallback_addresses(this_arg);
53384 return nativeResponseValue;
53386 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Bolt11Invoice_private_routes(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53388 export function Bolt11Invoice_private_routes(this_arg: bigint): number {
53389 if(!isWasmInitialized) {
53390 throw new Error("initializeWasm() must be awaited first!");
53392 const nativeResponseValue = wasm.TS_Bolt11Invoice_private_routes(this_arg);
53393 return nativeResponseValue;
53395 // MUST_USE_RES struct LDKCVec_RouteHintZ Bolt11Invoice_route_hints(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53397 export function Bolt11Invoice_route_hints(this_arg: bigint): number {
53398 if(!isWasmInitialized) {
53399 throw new Error("initializeWasm() must be awaited first!");
53401 const nativeResponseValue = wasm.TS_Bolt11Invoice_route_hints(this_arg);
53402 return nativeResponseValue;
53404 // MUST_USE_RES enum LDKCurrency Bolt11Invoice_currency(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53406 export function Bolt11Invoice_currency(this_arg: bigint): Currency {
53407 if(!isWasmInitialized) {
53408 throw new Error("initializeWasm() must be awaited first!");
53410 const nativeResponseValue = wasm.TS_Bolt11Invoice_currency(this_arg);
53411 return nativeResponseValue;
53413 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_amount_milli_satoshis(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53415 export function Bolt11Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
53416 if(!isWasmInitialized) {
53417 throw new Error("initializeWasm() must be awaited first!");
53419 const nativeResponseValue = wasm.TS_Bolt11Invoice_amount_milli_satoshis(this_arg);
53420 return nativeResponseValue;
53422 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
53424 export function Description_new(description: number): bigint {
53425 if(!isWasmInitialized) {
53426 throw new Error("initializeWasm() must be awaited first!");
53428 const nativeResponseValue = wasm.TS_Description_new(description);
53429 return nativeResponseValue;
53431 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
53433 export function Description_into_inner(this_arg: bigint): number {
53434 if(!isWasmInitialized) {
53435 throw new Error("initializeWasm() must be awaited first!");
53437 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
53438 return nativeResponseValue;
53440 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
53442 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
53443 if(!isWasmInitialized) {
53444 throw new Error("initializeWasm() must be awaited first!");
53446 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
53447 return nativeResponseValue;
53449 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
53451 export function ExpiryTime_from_duration(duration: bigint): bigint {
53452 if(!isWasmInitialized) {
53453 throw new Error("initializeWasm() must be awaited first!");
53455 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
53456 return nativeResponseValue;
53458 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
53460 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
53461 if(!isWasmInitialized) {
53462 throw new Error("initializeWasm() must be awaited first!");
53464 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
53465 return nativeResponseValue;
53467 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
53469 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
53470 if(!isWasmInitialized) {
53471 throw new Error("initializeWasm() must be awaited first!");
53473 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
53474 return nativeResponseValue;
53476 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
53478 export function PrivateRoute_new(hops: bigint): bigint {
53479 if(!isWasmInitialized) {
53480 throw new Error("initializeWasm() must be awaited first!");
53482 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
53483 return nativeResponseValue;
53485 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
53487 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
53488 if(!isWasmInitialized) {
53489 throw new Error("initializeWasm() must be awaited first!");
53491 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
53492 return nativeResponseValue;
53494 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
53496 export function CreationError_clone(orig: bigint): CreationError {
53497 if(!isWasmInitialized) {
53498 throw new Error("initializeWasm() must be awaited first!");
53500 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
53501 return nativeResponseValue;
53503 // enum LDKCreationError CreationError_description_too_long(void);
53505 export function CreationError_description_too_long(): CreationError {
53506 if(!isWasmInitialized) {
53507 throw new Error("initializeWasm() must be awaited first!");
53509 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
53510 return nativeResponseValue;
53512 // enum LDKCreationError CreationError_route_too_long(void);
53514 export function CreationError_route_too_long(): CreationError {
53515 if(!isWasmInitialized) {
53516 throw new Error("initializeWasm() must be awaited first!");
53518 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
53519 return nativeResponseValue;
53521 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
53523 export function CreationError_timestamp_out_of_bounds(): CreationError {
53524 if(!isWasmInitialized) {
53525 throw new Error("initializeWasm() must be awaited first!");
53527 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
53528 return nativeResponseValue;
53530 // enum LDKCreationError CreationError_invalid_amount(void);
53532 export function CreationError_invalid_amount(): CreationError {
53533 if(!isWasmInitialized) {
53534 throw new Error("initializeWasm() must be awaited first!");
53536 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
53537 return nativeResponseValue;
53539 // enum LDKCreationError CreationError_missing_route_hints(void);
53541 export function CreationError_missing_route_hints(): CreationError {
53542 if(!isWasmInitialized) {
53543 throw new Error("initializeWasm() must be awaited first!");
53545 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
53546 return nativeResponseValue;
53548 // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
53550 export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
53551 if(!isWasmInitialized) {
53552 throw new Error("initializeWasm() must be awaited first!");
53554 const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
53555 return nativeResponseValue;
53557 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
53559 export function CreationError_eq(a: bigint, b: bigint): boolean {
53560 if(!isWasmInitialized) {
53561 throw new Error("initializeWasm() must be awaited first!");
53563 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
53564 return nativeResponseValue;
53566 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
53568 export function CreationError_to_str(o: bigint): number {
53569 if(!isWasmInitialized) {
53570 throw new Error("initializeWasm() must be awaited first!");
53572 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
53573 return nativeResponseValue;
53575 // enum LDKBolt11SemanticError Bolt11SemanticError_clone(const enum LDKBolt11SemanticError *NONNULL_PTR orig);
53577 export function Bolt11SemanticError_clone(orig: bigint): Bolt11SemanticError {
53578 if(!isWasmInitialized) {
53579 throw new Error("initializeWasm() must be awaited first!");
53581 const nativeResponseValue = wasm.TS_Bolt11SemanticError_clone(orig);
53582 return nativeResponseValue;
53584 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_hash(void);
53586 export function Bolt11SemanticError_no_payment_hash(): Bolt11SemanticError {
53587 if(!isWasmInitialized) {
53588 throw new Error("initializeWasm() must be awaited first!");
53590 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_hash();
53591 return nativeResponseValue;
53593 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_hashes(void);
53595 export function Bolt11SemanticError_multiple_payment_hashes(): Bolt11SemanticError {
53596 if(!isWasmInitialized) {
53597 throw new Error("initializeWasm() must be awaited first!");
53599 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_hashes();
53600 return nativeResponseValue;
53602 // enum LDKBolt11SemanticError Bolt11SemanticError_no_description(void);
53604 export function Bolt11SemanticError_no_description(): Bolt11SemanticError {
53605 if(!isWasmInitialized) {
53606 throw new Error("initializeWasm() must be awaited first!");
53608 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_description();
53609 return nativeResponseValue;
53611 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_descriptions(void);
53613 export function Bolt11SemanticError_multiple_descriptions(): Bolt11SemanticError {
53614 if(!isWasmInitialized) {
53615 throw new Error("initializeWasm() must be awaited first!");
53617 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_descriptions();
53618 return nativeResponseValue;
53620 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_secret(void);
53622 export function Bolt11SemanticError_no_payment_secret(): Bolt11SemanticError {
53623 if(!isWasmInitialized) {
53624 throw new Error("initializeWasm() must be awaited first!");
53626 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_secret();
53627 return nativeResponseValue;
53629 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_secrets(void);
53631 export function Bolt11SemanticError_multiple_payment_secrets(): Bolt11SemanticError {
53632 if(!isWasmInitialized) {
53633 throw new Error("initializeWasm() must be awaited first!");
53635 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_secrets();
53636 return nativeResponseValue;
53638 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_features(void);
53640 export function Bolt11SemanticError_invalid_features(): Bolt11SemanticError {
53641 if(!isWasmInitialized) {
53642 throw new Error("initializeWasm() must be awaited first!");
53644 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_features();
53645 return nativeResponseValue;
53647 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_recovery_id(void);
53649 export function Bolt11SemanticError_invalid_recovery_id(): Bolt11SemanticError {
53650 if(!isWasmInitialized) {
53651 throw new Error("initializeWasm() must be awaited first!");
53653 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_recovery_id();
53654 return nativeResponseValue;
53656 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_signature(void);
53658 export function Bolt11SemanticError_invalid_signature(): Bolt11SemanticError {
53659 if(!isWasmInitialized) {
53660 throw new Error("initializeWasm() must be awaited first!");
53662 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_signature();
53663 return nativeResponseValue;
53665 // enum LDKBolt11SemanticError Bolt11SemanticError_imprecise_amount(void);
53667 export function Bolt11SemanticError_imprecise_amount(): Bolt11SemanticError {
53668 if(!isWasmInitialized) {
53669 throw new Error("initializeWasm() must be awaited first!");
53671 const nativeResponseValue = wasm.TS_Bolt11SemanticError_imprecise_amount();
53672 return nativeResponseValue;
53674 // bool Bolt11SemanticError_eq(const enum LDKBolt11SemanticError *NONNULL_PTR a, const enum LDKBolt11SemanticError *NONNULL_PTR b);
53676 export function Bolt11SemanticError_eq(a: bigint, b: bigint): boolean {
53677 if(!isWasmInitialized) {
53678 throw new Error("initializeWasm() must be awaited first!");
53680 const nativeResponseValue = wasm.TS_Bolt11SemanticError_eq(a, b);
53681 return nativeResponseValue;
53683 // struct LDKStr Bolt11SemanticError_to_str(const enum LDKBolt11SemanticError *NONNULL_PTR o);
53685 export function Bolt11SemanticError_to_str(o: bigint): number {
53686 if(!isWasmInitialized) {
53687 throw new Error("initializeWasm() must be awaited first!");
53689 const nativeResponseValue = wasm.TS_Bolt11SemanticError_to_str(o);
53690 return nativeResponseValue;
53692 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
53694 export function SignOrCreationError_free(this_ptr: bigint): void {
53695 if(!isWasmInitialized) {
53696 throw new Error("initializeWasm() must be awaited first!");
53698 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
53699 // debug statements here
53701 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
53703 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
53704 if(!isWasmInitialized) {
53705 throw new Error("initializeWasm() must be awaited first!");
53707 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
53708 return nativeResponseValue;
53710 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
53712 export function SignOrCreationError_clone(orig: bigint): bigint {
53713 if(!isWasmInitialized) {
53714 throw new Error("initializeWasm() must be awaited first!");
53716 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
53717 return nativeResponseValue;
53719 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
53721 export function SignOrCreationError_sign_error(): bigint {
53722 if(!isWasmInitialized) {
53723 throw new Error("initializeWasm() must be awaited first!");
53725 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
53726 return nativeResponseValue;
53728 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
53730 export function SignOrCreationError_creation_error(a: CreationError): bigint {
53731 if(!isWasmInitialized) {
53732 throw new Error("initializeWasm() must be awaited first!");
53734 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
53735 return nativeResponseValue;
53737 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
53739 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
53740 if(!isWasmInitialized) {
53741 throw new Error("initializeWasm() must be awaited first!");
53743 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
53744 return nativeResponseValue;
53746 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
53748 export function SignOrCreationError_to_str(o: bigint): number {
53749 if(!isWasmInitialized) {
53750 throw new Error("initializeWasm() must be awaited first!");
53752 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
53753 return nativeResponseValue;
53755 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ pay_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
53757 export function pay_invoice(invoice: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
53758 if(!isWasmInitialized) {
53759 throw new Error("initializeWasm() must be awaited first!");
53761 const nativeResponseValue = wasm.TS_pay_invoice(invoice, retry_strategy, channelmanager);
53762 return nativeResponseValue;
53764 // 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);
53766 export function pay_invoice_with_id(invoice: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
53767 if(!isWasmInitialized) {
53768 throw new Error("initializeWasm() must be awaited first!");
53770 const nativeResponseValue = wasm.TS_pay_invoice_with_id(invoice, payment_id, retry_strategy, channelmanager);
53771 return nativeResponseValue;
53773 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ pay_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
53775 export function pay_zero_value_invoice(invoice: bigint, amount_msats: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
53776 if(!isWasmInitialized) {
53777 throw new Error("initializeWasm() must be awaited first!");
53779 const nativeResponseValue = wasm.TS_pay_zero_value_invoice(invoice, amount_msats, retry_strategy, channelmanager);
53780 return nativeResponseValue;
53782 // 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);
53784 export function pay_zero_value_invoice_with_id(invoice: bigint, amount_msats: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
53785 if(!isWasmInitialized) {
53786 throw new Error("initializeWasm() must be awaited first!");
53788 const nativeResponseValue = wasm.TS_pay_zero_value_invoice_with_id(invoice, amount_msats, payment_id, retry_strategy, channelmanager);
53789 return nativeResponseValue;
53791 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ preflight_probe_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKCOption_u64Z liquidity_limit_multiplier);
53793 export function preflight_probe_invoice(invoice: bigint, channelmanager: bigint, liquidity_limit_multiplier: bigint): bigint {
53794 if(!isWasmInitialized) {
53795 throw new Error("initializeWasm() must be awaited first!");
53797 const nativeResponseValue = wasm.TS_preflight_probe_invoice(invoice, channelmanager, liquidity_limit_multiplier);
53798 return nativeResponseValue;
53800 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ preflight_probe_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msat, const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKCOption_u64Z liquidity_limit_multiplier);
53802 export function preflight_probe_zero_value_invoice(invoice: bigint, amount_msat: bigint, channelmanager: bigint, liquidity_limit_multiplier: bigint): bigint {
53803 if(!isWasmInitialized) {
53804 throw new Error("initializeWasm() must be awaited first!");
53806 const nativeResponseValue = wasm.TS_preflight_probe_zero_value_invoice(invoice, amount_msat, channelmanager, liquidity_limit_multiplier);
53807 return nativeResponseValue;
53809 // void PaymentError_free(struct LDKPaymentError this_ptr);
53811 export function PaymentError_free(this_ptr: bigint): void {
53812 if(!isWasmInitialized) {
53813 throw new Error("initializeWasm() must be awaited first!");
53815 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
53816 // debug statements here
53818 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
53820 export function PaymentError_clone_ptr(arg: bigint): bigint {
53821 if(!isWasmInitialized) {
53822 throw new Error("initializeWasm() must be awaited first!");
53824 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
53825 return nativeResponseValue;
53827 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
53829 export function PaymentError_clone(orig: bigint): bigint {
53830 if(!isWasmInitialized) {
53831 throw new Error("initializeWasm() must be awaited first!");
53833 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
53834 return nativeResponseValue;
53836 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
53838 export function PaymentError_invoice(a: number): bigint {
53839 if(!isWasmInitialized) {
53840 throw new Error("initializeWasm() must be awaited first!");
53842 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
53843 return nativeResponseValue;
53845 // struct LDKPaymentError PaymentError_sending(enum LDKRetryableSendFailure a);
53847 export function PaymentError_sending(a: RetryableSendFailure): bigint {
53848 if(!isWasmInitialized) {
53849 throw new Error("initializeWasm() must be awaited first!");
53851 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
53852 return nativeResponseValue;
53854 // bool PaymentError_eq(const struct LDKPaymentError *NONNULL_PTR a, const struct LDKPaymentError *NONNULL_PTR b);
53856 export function PaymentError_eq(a: bigint, b: bigint): boolean {
53857 if(!isWasmInitialized) {
53858 throw new Error("initializeWasm() must be awaited first!");
53860 const nativeResponseValue = wasm.TS_PaymentError_eq(a, b);
53861 return nativeResponseValue;
53863 // void ProbingError_free(struct LDKProbingError this_ptr);
53865 export function ProbingError_free(this_ptr: bigint): void {
53866 if(!isWasmInitialized) {
53867 throw new Error("initializeWasm() must be awaited first!");
53869 const nativeResponseValue = wasm.TS_ProbingError_free(this_ptr);
53870 // debug statements here
53872 // uint64_t ProbingError_clone_ptr(LDKProbingError *NONNULL_PTR arg);
53874 export function ProbingError_clone_ptr(arg: bigint): bigint {
53875 if(!isWasmInitialized) {
53876 throw new Error("initializeWasm() must be awaited first!");
53878 const nativeResponseValue = wasm.TS_ProbingError_clone_ptr(arg);
53879 return nativeResponseValue;
53881 // struct LDKProbingError ProbingError_clone(const struct LDKProbingError *NONNULL_PTR orig);
53883 export function ProbingError_clone(orig: bigint): bigint {
53884 if(!isWasmInitialized) {
53885 throw new Error("initializeWasm() must be awaited first!");
53887 const nativeResponseValue = wasm.TS_ProbingError_clone(orig);
53888 return nativeResponseValue;
53890 // struct LDKProbingError ProbingError_invoice(struct LDKStr a);
53892 export function ProbingError_invoice(a: number): bigint {
53893 if(!isWasmInitialized) {
53894 throw new Error("initializeWasm() must be awaited first!");
53896 const nativeResponseValue = wasm.TS_ProbingError_invoice(a);
53897 return nativeResponseValue;
53899 // struct LDKProbingError ProbingError_sending(struct LDKProbeSendFailure a);
53901 export function ProbingError_sending(a: bigint): bigint {
53902 if(!isWasmInitialized) {
53903 throw new Error("initializeWasm() must be awaited first!");
53905 const nativeResponseValue = wasm.TS_ProbingError_sending(a);
53906 return nativeResponseValue;
53908 // bool ProbingError_eq(const struct LDKProbingError *NONNULL_PTR a, const struct LDKProbingError *NONNULL_PTR b);
53910 export function ProbingError_eq(a: bigint, b: bigint): boolean {
53911 if(!isWasmInitialized) {
53912 throw new Error("initializeWasm() must be awaited first!");
53914 const nativeResponseValue = wasm.TS_ProbingError_eq(a, b);
53915 return nativeResponseValue;
53917 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice(struct LDKCOption_u64Z amt_msat, struct LDKCOption_ThirtyTwoBytesZ 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);
53919 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 {
53920 if(!isWasmInitialized) {
53921 throw new Error("initializeWasm() must be awaited first!");
53923 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);
53924 return nativeResponseValue;
53926 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice_with_description_hash(struct LDKCOption_u64Z amt_msat, struct LDKCOption_ThirtyTwoBytesZ 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);
53928 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 {
53929 if(!isWasmInitialized) {
53930 throw new Error("initializeWasm() must be awaited first!");
53932 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);
53933 return nativeResponseValue;
53935 // 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);
53937 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 {
53938 if(!isWasmInitialized) {
53939 throw new Error("initializeWasm() must be awaited first!");
53941 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);
53942 return nativeResponseValue;
53944 // 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);
53946 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 {
53947 if(!isWasmInitialized) {
53948 throw new Error("initializeWasm() must be awaited first!");
53950 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);
53951 return nativeResponseValue;
53953 // 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);
53955 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 {
53956 if(!isWasmInitialized) {
53957 throw new Error("initializeWasm() must be awaited first!");
53959 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);
53960 return nativeResponseValue;
53962 // struct LDKCResult_SiPrefixBolt11ParseErrorZ SiPrefix_from_str(struct LDKStr s);
53964 export function SiPrefix_from_str(s: number): bigint {
53965 if(!isWasmInitialized) {
53966 throw new Error("initializeWasm() must be awaited first!");
53968 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
53969 return nativeResponseValue;
53971 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ Bolt11Invoice_from_str(struct LDKStr s);
53973 export function Bolt11Invoice_from_str(s: number): bigint {
53974 if(!isWasmInitialized) {
53975 throw new Error("initializeWasm() must be awaited first!");
53977 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_str(s);
53978 return nativeResponseValue;
53980 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ SignedRawBolt11Invoice_from_str(struct LDKStr s);
53982 export function SignedRawBolt11Invoice_from_str(s: number): bigint {
53983 if(!isWasmInitialized) {
53984 throw new Error("initializeWasm() must be awaited first!");
53986 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_from_str(s);
53987 return nativeResponseValue;
53989 // struct LDKStr Bolt11ParseError_to_str(const struct LDKBolt11ParseError *NONNULL_PTR o);
53991 export function Bolt11ParseError_to_str(o: bigint): number {
53992 if(!isWasmInitialized) {
53993 throw new Error("initializeWasm() must be awaited first!");
53995 const nativeResponseValue = wasm.TS_Bolt11ParseError_to_str(o);
53996 return nativeResponseValue;
53998 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
54000 export function ParseOrSemanticError_to_str(o: bigint): number {
54001 if(!isWasmInitialized) {
54002 throw new Error("initializeWasm() must be awaited first!");
54004 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
54005 return nativeResponseValue;
54007 // struct LDKStr Bolt11Invoice_to_str(const struct LDKBolt11Invoice *NONNULL_PTR o);
54009 export function Bolt11Invoice_to_str(o: bigint): number {
54010 if(!isWasmInitialized) {
54011 throw new Error("initializeWasm() must be awaited first!");
54013 const nativeResponseValue = wasm.TS_Bolt11Invoice_to_str(o);
54014 return nativeResponseValue;
54016 // struct LDKStr SignedRawBolt11Invoice_to_str(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
54018 export function SignedRawBolt11Invoice_to_str(o: bigint): number {
54019 if(!isWasmInitialized) {
54020 throw new Error("initializeWasm() must be awaited first!");
54022 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_to_str(o);
54023 return nativeResponseValue;
54025 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
54027 export function Currency_to_str(o: bigint): number {
54028 if(!isWasmInitialized) {
54029 throw new Error("initializeWasm() must be awaited first!");
54031 const nativeResponseValue = wasm.TS_Currency_to_str(o);
54032 return nativeResponseValue;
54034 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
54036 export function SiPrefix_to_str(o: bigint): number {
54037 if(!isWasmInitialized) {
54038 throw new Error("initializeWasm() must be awaited first!");
54040 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
54041 return nativeResponseValue;
54045 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) {
54046 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
54047 if (weak == null || weak == undefined) {
54048 console.error("Got function call on unknown/free'd JS object!");
54049 throw new Error("Got function call on unknown/free'd JS object!");
54051 const obj = weak.deref();
54052 if (obj == null || obj == undefined) {
54053 console.error("Got function call on GC'd JS object!");
54054 throw new Error("Got function call on GC'd JS object!");
54058 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
54059 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
54060 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
54061 case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
54062 case 4: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
54063 case 5: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
54064 case 6: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
54065 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
54066 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
54067 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
54068 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_htlc_transaction"); break;
54069 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
54070 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
54071 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
54072 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
54073 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54074 case 16: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
54075 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
54076 case 18: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
54077 case 19: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
54078 case 20: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
54079 case 21: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transactions"); break;
54080 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
54081 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
54082 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
54083 case 25: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
54084 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
54085 case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice_request"); break;
54086 case 28: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice"); break;
54087 case 29: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
54088 case 30: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
54089 case 31: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
54090 case 32: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
54091 case 33: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
54092 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
54093 case 35: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
54094 case 36: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
54095 case 37: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
54096 case 38: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
54097 case 39: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
54098 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54099 case 41: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
54100 case 42: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54101 case 43: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
54102 case 44: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
54103 case 45: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
54104 case 46: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54105 case 47: fn = Object.getOwnPropertyDescriptor(obj, "remove"); break;
54106 case 48: fn = Object.getOwnPropertyDescriptor(obj, "list"); break;
54107 case 49: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
54108 case 50: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
54109 case 51: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
54110 case 52: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
54111 case 53: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
54112 case 54: fn = Object.getOwnPropertyDescriptor(obj, "read_lock"); break;
54113 case 55: fn = Object.getOwnPropertyDescriptor(obj, "write_lock"); break;
54114 case 56: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54115 case 57: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
54116 case 58: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
54117 case 59: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
54118 case 60: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
54119 case 61: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
54120 case 62: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
54121 case 63: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
54122 case 64: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
54123 case 65: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
54124 case 66: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
54125 case 67: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
54126 case 68: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
54127 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
54128 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
54129 case 71: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
54130 case 72: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
54131 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
54132 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel_v2"); break;
54133 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
54134 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel_v2"); break;
54135 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
54136 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
54137 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
54138 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
54139 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
54140 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_input"); break;
54141 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_output"); break;
54142 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_input"); break;
54143 case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_output"); break;
54144 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_complete"); break;
54145 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_signatures"); break;
54146 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_init_rbf"); break;
54147 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_ack_rbf"); break;
54148 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_abort"); break;
54149 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
54150 case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
54151 case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
54152 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
54153 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
54154 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
54155 case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
54156 case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
54157 case 99: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
54158 case 100: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
54159 case 101: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
54160 case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
54161 case 103: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
54162 case 104: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54163 case 105: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54164 case 106: fn = Object.getOwnPropertyDescriptor(obj, "get_genesis_hashes"); break;
54165 case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
54166 case 108: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
54167 case 109: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
54168 case 110: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
54169 case 111: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
54170 case 112: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
54171 case 113: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
54172 case 114: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
54173 case 115: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
54174 case 116: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
54175 case 117: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
54176 case 118: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54177 case 119: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54178 case 120: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
54179 case 121: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
54180 case 122: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
54181 case 123: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
54182 case 124: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54183 case 125: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54184 case 126: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
54185 case 127: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
54186 case 128: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
54187 case 129: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54188 case 130: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54189 case 131: fn = Object.getOwnPropertyDescriptor(obj, "handle_message"); break;
54190 case 132: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
54191 case 133: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
54192 case 134: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
54193 case 135: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
54194 case 136: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
54195 case 137: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
54196 case 138: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54197 case 139: fn = Object.getOwnPropertyDescriptor(obj, "find_path"); break;
54198 case 140: fn = Object.getOwnPropertyDescriptor(obj, "select_confirmed_utxos"); break;
54199 case 141: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
54200 case 142: fn = Object.getOwnPropertyDescriptor(obj, "list_confirmed_utxos"); break;
54201 case 143: fn = Object.getOwnPropertyDescriptor(obj, "get_change_script"); break;
54202 case 144: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
54204 console.error("Got unknown function call with id " + fn_id + " from C!");
54205 throw new Error("Got unknown function call with id " + fn_id + " from C!");
54207 if (fn == null || fn == undefined) {
54208 console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
54209 throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
54213 ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
54215 console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
54219 if (ret === undefined || ret === null) return BigInt(0);
54220 return BigInt(ret);