2 import * as version from './version.mjs';
3 import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
5 const imports: any = {};
8 var js_objs: Array<WeakRef<object>> = [];
9 var js_invoke: Function;
10 var getRandomValues: Function;
12 imports.wasi_snapshot_preview1 = {
13 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number, bytes_written_ptr: number) => {
14 // This should generally only be used to print panic messages
15 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
16 var bytes_written = 0;
17 for (var i = 0; i < iovec_array_len; i++) {
18 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
19 console.log("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
20 bytes_written += ptr_len_view[i*2+1];
22 const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
23 written_view[0] = bytes_written;
26 "fd_close": (_fd: number) => {
27 // This is not generally called, but may be referenced in debug builds
28 console.log("wasi_snapshot_preview1:fd_close");
29 return 58; // Not Supported
31 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
32 // This is not generally called, but may be referenced in debug builds
33 console.log("wasi_snapshot_preview1:fd_seek");
34 return 58; // Not Supported
36 "random_get": (buf_ptr: number, buf_len: number) => {
37 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
41 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
42 // This is called before fd_write to format + print panic messages
43 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
44 out_count_view[0] = 0;
45 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
49 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
50 // This is called before fd_write to format + print panic messages,
51 // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
52 console.log("wasi_snapshot_preview1:environ_get");
53 return 58; // Note supported - we said there were 0 environment entries!
56 console.log("wasi_snapshot_preview1:proc_exit");
61 let isWasmInitialized: boolean = false;
63 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
64 if (typeof crypto === "undefined") {
65 var crypto_import = (await import('crypto')).webcrypto;
66 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
68 getRandomValues = crypto.getRandomValues.bind(crypto);
71 wasm = wasmInstance.exports;
72 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
73 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
76 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
77 throw new Error("Compiled LDK library and LDK class files do not match");
78 // Fetching the LDK versions from C also checks that the header and binaries match
79 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
80 const ldk_ver: number = wasm.TS_get_ldk_version();
81 if (c_bindings_ver == 0)
82 throw new Error("LDK version did not match the header we built against");
84 throw new Error("LDK C bindings version did not match the header we built against");
85 const c_bindings_version: string = decodeString(c_bindings_ver)
86 const ldk_version: string = decodeString(ldk_ver);
87 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
89 isWasmInitialized = true;
92 const fn_list = ["uuuuuu", "buuuuu", "bbuuuu", "bbbuuu", "bbbbuu",
93 "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uububu"];
96 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
97 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
98 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
99 await finishInitializeWasm(wasmInstance);
103 export async function initializeWasmFetch(uri: string) {
104 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
105 const stream = fetch(uri);
106 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
107 await finishInitializeWasm(wasmInstance);
112 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
113 const arr = new Uint8Array(inputArray.length);
114 for (var i = 0; i < inputArray.length; i++) {
115 arr[i] = inputArray[i].getVal();
121 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
122 const arr = new Uint8Array(inputArray.length);
123 for (var i = 0; i < inputArray.length; i++) {
124 arr[i] = inputArray[i].getVal();
132 export function encodeUint8Array (inputArray: Uint8Array): number {
133 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
134 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
135 arrayLengthView[0] = BigInt(inputArray.length);
136 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
137 arrayMemoryView.set(inputArray);
138 return cArrayPointer;
141 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
142 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
143 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
144 arrayLengthView[0] = BigInt(inputArray.length);
145 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
146 arrayMemoryView.set(inputArray);
147 return cArrayPointer;
150 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
151 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
152 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
153 arrayMemoryView.set(inputArray, 1);
154 arrayMemoryView[0] = BigInt(inputArray.length);
155 return cArrayPointer;
159 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
160 if (arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
165 export function getArrayLength(arrayPointer: number): number {
166 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
167 const len = arraySizeViewer[0];
168 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
169 return Number(len % (2n ** 32n));
172 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
173 const arraySize = getArrayLength(arrayPointer);
174 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
175 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
176 // will free the underlying memory when it becomes unreachable instead of copying here.
177 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
178 const actualArray = actualArrayViewer.slice(0, arraySize);
180 wasm.TS_free(arrayPointer);
184 const decodeUint32Array = (arrayPointer: number, free = true) => {
185 const arraySize = getArrayLength(arrayPointer);
186 const actualArrayViewer = new Uint32Array(
187 wasm.memory.buffer, // value
188 arrayPointer + 8, // offset (ignoring length bytes)
189 arraySize // uint32 count
191 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
192 // will free the underlying memory when it becomes unreachable instead of copying here.
193 const actualArray = actualArrayViewer.slice(0, arraySize);
195 wasm.TS_free(arrayPointer);
200 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
201 const arraySize = getArrayLength(arrayPointer);
202 const actualArrayViewer = new BigUint64Array(
203 wasm.memory.buffer, // value
204 arrayPointer + 8, // offset (ignoring length bytes)
205 arraySize // uint32 count
207 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
208 // will free the underlying memory when it becomes unreachable instead of copying here.
209 const actualArray = new Array(arraySize);
210 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
212 wasm.TS_free(arrayPointer);
217 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
220 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
221 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
222 return actualArrayViewer[idx];
226 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
227 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
228 return actualArrayViewer[idx];
232 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
233 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
234 return actualArrayViewer[idx];
239 export function encodeString(str: string): number {
240 const charArray = new TextEncoder().encode(str);
241 return encodeUint8Array(charArray);
245 export function decodeString(stringPointer: number, free = true): string {
246 const arraySize = getArrayLength(stringPointer);
247 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
248 const result = new TextDecoder("utf-8").decode(memoryView);
251 wasm.TS_free(stringPointer);
257 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
258 /* @internal */ export function debugPrintRemainingAllocs() { }
261 * An error when accessing the chain via [`Access`].
263 export enum AccessError {
265 * The requested chain is unknown.
267 LDKAccessError_UnknownChain,
269 * The requested transaction doesn't exist or hasn't confirmed.
271 LDKAccessError_UnknownTx,
276 * An enum which can either contain a or not
278 export enum COption_NoneZ {
280 * When we're in this state, this COption_NoneZ contains a
282 LDKCOption_NoneZ_Some,
284 * When we're in this state, this COption_NoneZ contains nothing
286 LDKCOption_NoneZ_None,
291 * An error enum representing a failure to persist a channel monitor update.
293 export enum ChannelMonitorUpdateErr {
295 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
296 our state failed, but is expected to succeed at some point in the future).
298 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
299 submitting new commitment transactions to the counterparty. Once the update(s) that failed
300 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
301 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
304 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
305 you return a TemporaryFailure you must ensure that it is written to disk safely before
306 writing out the latest ChannelManager state.
308 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
309 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
310 to claim it on this channel) and those updates must be applied wherever they can be. At
311 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
312 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
313 the channel which would invalidate previous ChannelMonitors are not made when a channel has
316 Note that even if updates made after TemporaryFailure succeed you must still provide a
317 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
318 normal channel operation. Note that this is normally generated through a call to
319 [`ChainMonitor::channel_monitor_updated`].
321 Note that the update being processed here will not be replayed for you when you return a
322 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
323 you must store the update itself on your own local disk prior to returning a
324 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
325 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
328 For deployments where a copy of ChannelMonitors and other local state are backed up in a
329 remote location (with local copies persisted immediately), it is anticipated that all
330 updates will return TemporaryFailure until the remote copies could be updated.
332 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
334 LDKChannelMonitorUpdateErr_TemporaryFailure,
336 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
337 different watchtower and cannot update with all watchtowers that were previously informed
340 At reception of this error, ChannelManager will force-close the channel and return at
341 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
342 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
343 update must be rejected.
345 This failure may also signal a failure to update the local persisted copy of one of
346 the channel monitor instance.
348 Note that even when you fail a holder commitment transaction update, you must store the
349 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
350 broadcasts it (e.g distributed channel-monitor deployment)
352 In case of distributed watchtowers deployment, the new version must be written to disk, as
353 state may have been stored but rejected due to a block forcing a commitment broadcast. This
354 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
355 lagging behind on block processing.
357 LDKChannelMonitorUpdateErr_PermanentFailure,
362 * An enum that represents the speed at which we want a transaction to confirm used for feerate
365 export enum ConfirmationTarget {
367 * We are happy with this transaction confirming slowly when feerate drops some.
369 LDKConfirmationTarget_Background,
371 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
373 LDKConfirmationTarget_Normal,
375 * We'd like this transaction to confirm in the next few blocks.
377 LDKConfirmationTarget_HighPriority,
382 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
384 export enum CreationError {
386 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
388 LDKCreationError_DescriptionTooLong,
390 * The specified route has too many hops and can't be encoded
392 LDKCreationError_RouteTooLong,
394 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
396 LDKCreationError_TimestampOutOfBounds,
398 * The supplied millisatoshi amount was greater than the total bitcoin supply.
400 LDKCreationError_InvalidAmount,
402 * Route hints were required for this invoice and were missing. Applies to
405 [phantom invoices]: crate::utils::create_phantom_invoice
407 LDKCreationError_MissingRouteHints,
412 * Enum representing the crypto currencies (or networks) supported by this library
414 export enum Currency {
422 LDKCurrency_BitcoinTestnet,
439 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
441 export enum IOError {
443 LDKIOError_PermissionDenied,
444 LDKIOError_ConnectionRefused,
445 LDKIOError_ConnectionReset,
446 LDKIOError_ConnectionAborted,
447 LDKIOError_NotConnected,
448 LDKIOError_AddrInUse,
449 LDKIOError_AddrNotAvailable,
450 LDKIOError_BrokenPipe,
451 LDKIOError_AlreadyExists,
452 LDKIOError_WouldBlock,
453 LDKIOError_InvalidInput,
454 LDKIOError_InvalidData,
456 LDKIOError_WriteZero,
457 LDKIOError_Interrupted,
459 LDKIOError_UnexpectedEof,
464 * An enum representing the available verbosity levels of the logger.
468 * Designates extremely verbose information, including gossip-induced messages
472 * Designates very low priority, often extremely verbose, information
476 * Designates lower priority information
480 * Designates useful information
484 * Designates hazardous situations
488 * Designates very serious errors
495 * An enum representing the possible Bitcoin or test networks which we can run on
497 export enum Network {
499 * The main Bitcoin blockchain.
503 * The testnet3 blockchain.
507 * A local test blockchain.
511 * A blockchain on which blocks are signed instead of mined.
518 * Specifies the recipient of an invoice, to indicate to [`KeysInterface::sign_invoice`] what node
519 * secret key should be used to sign the invoice.
521 export enum Recipient {
523 * The invoice should be signed with the local node secret key.
527 * The invoice should be signed with the phantom node secret key. This secret key must be the
528 same for all nodes participating in the [phantom node payment].
530 [phantom node payment]: PhantomKeysManager
532 LDKRecipient_PhantomNode,
537 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
539 export enum Secp256k1Error {
541 * Signature failed verification
543 LDKSecp256k1Error_IncorrectSignature,
545 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
547 LDKSecp256k1Error_InvalidMessage,
551 LDKSecp256k1Error_InvalidPublicKey,
555 LDKSecp256k1Error_InvalidSignature,
559 LDKSecp256k1Error_InvalidSecretKey,
563 LDKSecp256k1Error_InvalidSharedSecret,
567 LDKSecp256k1Error_InvalidRecoveryId,
569 * Invalid tweak for add_assign or mul_assign
571 LDKSecp256k1Error_InvalidTweak,
573 * Didn't pass enough memory to context creation with preallocated memory
575 LDKSecp256k1Error_NotEnoughMemory,
577 * Bad set of public keys.
579 LDKSecp256k1Error_InvalidPublicKeySum,
581 * The only valid parity values are 0 or 1.
583 LDKSecp256k1Error_InvalidParityValue,
588 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
589 * requirements sections in BOLT #11
591 export enum SemanticError {
593 * The invoice is missing the mandatory payment hash
595 LDKSemanticError_NoPaymentHash,
597 * The invoice has multiple payment hashes which isn't allowed
599 LDKSemanticError_MultiplePaymentHashes,
601 * No description or description hash are part of the invoice
603 LDKSemanticError_NoDescription,
605 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
607 LDKSemanticError_MultipleDescriptions,
609 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
612 LDKSemanticError_NoPaymentSecret,
614 * The invoice contains multiple payment secrets
616 LDKSemanticError_MultiplePaymentSecrets,
618 * The invoice's features are invalid
620 LDKSemanticError_InvalidFeatures,
622 * The recovery id doesn't fit the signature/pub key
624 LDKSemanticError_InvalidRecoveryId,
626 * The invoice's signature is invalid
628 LDKSemanticError_InvalidSignature,
630 * The invoice's amount was not a whole number of millisatoshis
632 LDKSemanticError_ImpreciseAmount,
637 * SI prefixes for the human readable part
639 export enum SiPrefix {
659 export class LDKBech32Error {
660 protected constructor() {}
663 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
664 if(!isWasmInitialized) {
665 throw new Error("initializeWasm() must be awaited first!");
667 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
668 return nativeResponseValue;
671 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
672 if(!isWasmInitialized) {
673 throw new Error("initializeWasm() must be awaited first!");
675 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
676 return nativeResponseValue;
679 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
680 if(!isWasmInitialized) {
681 throw new Error("initializeWasm() must be awaited first!");
683 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
684 return nativeResponseValue;
686 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
688 export function TxOut_get_script_pubkey(thing: bigint): number {
689 if(!isWasmInitialized) {
690 throw new Error("initializeWasm() must be awaited first!");
692 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
693 return nativeResponseValue;
695 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
697 export function TxOut_get_value(thing: bigint): bigint {
698 if(!isWasmInitialized) {
699 throw new Error("initializeWasm() must be awaited first!");
701 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
702 return nativeResponseValue;
704 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
706 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
707 if(!isWasmInitialized) {
708 throw new Error("initializeWasm() must be awaited first!");
710 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
711 // debug statements here
713 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
715 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
716 if(!isWasmInitialized) {
717 throw new Error("initializeWasm() must be awaited first!");
719 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
720 // debug statements here
722 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
724 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
725 if(!isWasmInitialized) {
726 throw new Error("initializeWasm() must be awaited first!");
728 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
729 return nativeResponseValue;
731 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
733 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
734 if(!isWasmInitialized) {
735 throw new Error("initializeWasm() must be awaited first!");
737 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
738 return nativeResponseValue;
740 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
742 export function CResult_SecretKeyErrorZ_get_ok(owner: bigint): number {
743 if(!isWasmInitialized) {
744 throw new Error("initializeWasm() must be awaited first!");
746 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
747 return nativeResponseValue;
749 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
751 export function CResult_SecretKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
752 if(!isWasmInitialized) {
753 throw new Error("initializeWasm() must be awaited first!");
755 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
756 return nativeResponseValue;
758 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
760 export function CResult_PublicKeyErrorZ_get_ok(owner: bigint): number {
761 if(!isWasmInitialized) {
762 throw new Error("initializeWasm() must be awaited first!");
764 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
765 return nativeResponseValue;
767 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
769 export function CResult_PublicKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
770 if(!isWasmInitialized) {
771 throw new Error("initializeWasm() must be awaited first!");
773 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
774 return nativeResponseValue;
776 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
778 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
783 return nativeResponseValue;
785 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
787 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
788 if(!isWasmInitialized) {
789 throw new Error("initializeWasm() must be awaited first!");
791 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
792 return nativeResponseValue;
794 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
796 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
797 if(!isWasmInitialized) {
798 throw new Error("initializeWasm() must be awaited first!");
800 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
801 return nativeResponseValue;
803 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
805 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
806 if(!isWasmInitialized) {
807 throw new Error("initializeWasm() must be awaited first!");
809 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
810 return nativeResponseValue;
812 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
814 export function CResult_TxCreationKeysErrorZ_get_ok(owner: bigint): bigint {
815 if(!isWasmInitialized) {
816 throw new Error("initializeWasm() must be awaited first!");
818 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
819 return nativeResponseValue;
821 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
823 export function CResult_TxCreationKeysErrorZ_get_err(owner: bigint): Secp256k1Error {
824 if(!isWasmInitialized) {
825 throw new Error("initializeWasm() must be awaited first!");
827 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
828 return nativeResponseValue;
831 export class LDKCOption_u32Z {
832 protected constructor() {}
835 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
836 if(!isWasmInitialized) {
837 throw new Error("initializeWasm() must be awaited first!");
839 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
840 return nativeResponseValue;
843 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
844 if(!isWasmInitialized) {
845 throw new Error("initializeWasm() must be awaited first!");
847 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
848 return nativeResponseValue;
850 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
852 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
853 if(!isWasmInitialized) {
854 throw new Error("initializeWasm() must be awaited first!");
856 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
857 return nativeResponseValue;
859 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
861 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
862 if(!isWasmInitialized) {
863 throw new Error("initializeWasm() must be awaited first!");
865 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
866 return nativeResponseValue;
868 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
870 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
871 if(!isWasmInitialized) {
872 throw new Error("initializeWasm() must be awaited first!");
874 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
875 return nativeResponseValue;
877 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
879 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
880 if(!isWasmInitialized) {
881 throw new Error("initializeWasm() must be awaited first!");
883 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
884 return nativeResponseValue;
886 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
888 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
889 if(!isWasmInitialized) {
890 throw new Error("initializeWasm() must be awaited first!");
892 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
893 return nativeResponseValue;
895 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
897 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
898 if(!isWasmInitialized) {
899 throw new Error("initializeWasm() must be awaited first!");
901 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
902 return nativeResponseValue;
904 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
906 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
907 if(!isWasmInitialized) {
908 throw new Error("initializeWasm() must be awaited first!");
910 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
911 return nativeResponseValue;
913 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
915 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
916 if(!isWasmInitialized) {
917 throw new Error("initializeWasm() must be awaited first!");
919 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
920 return nativeResponseValue;
922 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
924 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
925 if(!isWasmInitialized) {
926 throw new Error("initializeWasm() must be awaited first!");
928 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
929 return nativeResponseValue;
931 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
933 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
934 if(!isWasmInitialized) {
935 throw new Error("initializeWasm() must be awaited first!");
937 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
938 return nativeResponseValue;
940 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
942 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
943 if(!isWasmInitialized) {
944 throw new Error("initializeWasm() must be awaited first!");
946 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
947 return nativeResponseValue;
949 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
951 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
952 if(!isWasmInitialized) {
953 throw new Error("initializeWasm() must be awaited first!");
955 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
956 // debug statements here
958 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
960 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
961 if(!isWasmInitialized) {
962 throw new Error("initializeWasm() must be awaited first!");
964 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
965 return nativeResponseValue;
967 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
969 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
970 if(!isWasmInitialized) {
971 throw new Error("initializeWasm() must be awaited first!");
973 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
974 return nativeResponseValue;
976 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
978 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
979 if(!isWasmInitialized) {
980 throw new Error("initializeWasm() must be awaited first!");
982 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
983 return nativeResponseValue;
985 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
987 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
988 if(!isWasmInitialized) {
989 throw new Error("initializeWasm() must be awaited first!");
991 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
992 // debug statements here
994 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
996 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: bigint): number {
997 if(!isWasmInitialized) {
998 throw new Error("initializeWasm() must be awaited first!");
1000 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
1001 return nativeResponseValue;
1003 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
1005 export function CResult_CVec_SignatureZNoneZ_get_err(owner: bigint): void {
1006 if(!isWasmInitialized) {
1007 throw new Error("initializeWasm() must be awaited first!");
1009 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1010 // debug statements here
1012 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1014 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
1015 if(!isWasmInitialized) {
1016 throw new Error("initializeWasm() must be awaited first!");
1018 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1019 return nativeResponseValue;
1021 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1023 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
1024 if(!isWasmInitialized) {
1025 throw new Error("initializeWasm() must be awaited first!");
1027 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1028 return nativeResponseValue;
1030 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1032 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
1033 if(!isWasmInitialized) {
1034 throw new Error("initializeWasm() must be awaited first!");
1036 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1037 return nativeResponseValue;
1039 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1041 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
1042 if(!isWasmInitialized) {
1043 throw new Error("initializeWasm() must be awaited first!");
1045 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1046 return nativeResponseValue;
1048 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1050 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1051 if(!isWasmInitialized) {
1052 throw new Error("initializeWasm() must be awaited first!");
1054 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1055 return nativeResponseValue;
1057 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1059 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
1060 if(!isWasmInitialized) {
1061 throw new Error("initializeWasm() must be awaited first!");
1063 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1064 return nativeResponseValue;
1066 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1068 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
1069 if(!isWasmInitialized) {
1070 throw new Error("initializeWasm() must be awaited first!");
1072 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1073 return nativeResponseValue;
1075 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1077 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
1078 if(!isWasmInitialized) {
1079 throw new Error("initializeWasm() must be awaited first!");
1081 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1082 return nativeResponseValue;
1084 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1086 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1087 if(!isWasmInitialized) {
1088 throw new Error("initializeWasm() must be awaited first!");
1090 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1091 return nativeResponseValue;
1093 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1095 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1096 if(!isWasmInitialized) {
1097 throw new Error("initializeWasm() must be awaited first!");
1099 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
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 LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1124 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1125 if(!isWasmInitialized) {
1126 throw new Error("initializeWasm() must be awaited first!");
1128 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1129 return nativeResponseValue;
1131 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1133 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1134 if(!isWasmInitialized) {
1135 throw new Error("initializeWasm() must be awaited first!");
1137 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1138 return nativeResponseValue;
1140 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1142 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
1143 if(!isWasmInitialized) {
1144 throw new Error("initializeWasm() must be awaited first!");
1146 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1147 return nativeResponseValue;
1149 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1151 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
1152 if(!isWasmInitialized) {
1153 throw new Error("initializeWasm() must be awaited first!");
1155 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1156 return nativeResponseValue;
1158 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1160 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
1161 if(!isWasmInitialized) {
1162 throw new Error("initializeWasm() must be awaited first!");
1164 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1165 return nativeResponseValue;
1167 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1169 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
1170 if(!isWasmInitialized) {
1171 throw new Error("initializeWasm() must be awaited first!");
1173 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1174 return nativeResponseValue;
1176 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1178 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
1179 if(!isWasmInitialized) {
1180 throw new Error("initializeWasm() must be awaited first!");
1182 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1183 return nativeResponseValue;
1185 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1187 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
1188 if(!isWasmInitialized) {
1189 throw new Error("initializeWasm() must be awaited first!");
1191 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1192 return nativeResponseValue;
1195 export class LDKPaymentPurpose {
1196 protected constructor() {}
1199 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
1200 if(!isWasmInitialized) {
1201 throw new Error("initializeWasm() must be awaited first!");
1203 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1204 return nativeResponseValue;
1207 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): number {
1208 if(!isWasmInitialized) {
1209 throw new Error("initializeWasm() must be awaited first!");
1211 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1212 return nativeResponseValue;
1215 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
1216 if(!isWasmInitialized) {
1217 throw new Error("initializeWasm() must be awaited first!");
1219 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1220 return nativeResponseValue;
1223 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
1224 if(!isWasmInitialized) {
1225 throw new Error("initializeWasm() must be awaited first!");
1227 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1228 return nativeResponseValue;
1230 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1232 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1237 return nativeResponseValue;
1239 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1241 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
1242 if(!isWasmInitialized) {
1243 throw new Error("initializeWasm() must be awaited first!");
1245 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1246 return nativeResponseValue;
1249 export class LDKClosureReason {
1250 protected constructor() {}
1253 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
1254 if(!isWasmInitialized) {
1255 throw new Error("initializeWasm() must be awaited first!");
1257 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1258 return nativeResponseValue;
1261 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): number {
1262 if(!isWasmInitialized) {
1263 throw new Error("initializeWasm() must be awaited first!");
1265 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1266 return nativeResponseValue;
1269 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
1270 if(!isWasmInitialized) {
1271 throw new Error("initializeWasm() must be awaited first!");
1273 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1274 return nativeResponseValue;
1277 export class LDKCOption_ClosureReasonZ {
1278 protected constructor() {}
1281 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
1282 if(!isWasmInitialized) {
1283 throw new Error("initializeWasm() must be awaited first!");
1285 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1286 return nativeResponseValue;
1289 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
1290 if(!isWasmInitialized) {
1291 throw new Error("initializeWasm() must be awaited first!");
1293 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1294 return nativeResponseValue;
1296 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1298 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
1299 if(!isWasmInitialized) {
1300 throw new Error("initializeWasm() must be awaited first!");
1302 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1303 return nativeResponseValue;
1305 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1307 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
1308 if(!isWasmInitialized) {
1309 throw new Error("initializeWasm() must be awaited first!");
1311 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1312 return nativeResponseValue;
1315 export class LDKHTLCDestination {
1316 protected constructor() {}
1319 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
1320 if(!isWasmInitialized) {
1321 throw new Error("initializeWasm() must be awaited first!");
1323 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1324 return nativeResponseValue;
1327 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
1328 if(!isWasmInitialized) {
1329 throw new Error("initializeWasm() must be awaited first!");
1331 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1332 return nativeResponseValue;
1335 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
1336 if(!isWasmInitialized) {
1337 throw new Error("initializeWasm() must be awaited first!");
1339 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1340 return nativeResponseValue;
1343 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
1344 if(!isWasmInitialized) {
1345 throw new Error("initializeWasm() must be awaited first!");
1347 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1348 return nativeResponseValue;
1351 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
1352 if(!isWasmInitialized) {
1353 throw new Error("initializeWasm() must be awaited first!");
1355 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1356 return nativeResponseValue;
1359 export class LDKCOption_HTLCDestinationZ {
1360 protected constructor() {}
1363 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
1364 if(!isWasmInitialized) {
1365 throw new Error("initializeWasm() must be awaited first!");
1367 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1368 return nativeResponseValue;
1371 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
1372 if(!isWasmInitialized) {
1373 throw new Error("initializeWasm() must be awaited first!");
1375 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1376 return nativeResponseValue;
1378 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1380 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
1381 if(!isWasmInitialized) {
1382 throw new Error("initializeWasm() must be awaited first!");
1384 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1385 return nativeResponseValue;
1387 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1389 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
1390 if(!isWasmInitialized) {
1391 throw new Error("initializeWasm() must be awaited first!");
1393 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1394 return nativeResponseValue;
1397 export class LDKNetworkUpdate {
1398 protected constructor() {}
1401 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
1402 if(!isWasmInitialized) {
1403 throw new Error("initializeWasm() must be awaited first!");
1405 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1406 return nativeResponseValue;
1409 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
1410 if(!isWasmInitialized) {
1411 throw new Error("initializeWasm() must be awaited first!");
1413 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1414 return nativeResponseValue;
1417 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
1418 if(!isWasmInitialized) {
1419 throw new Error("initializeWasm() must be awaited first!");
1421 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1422 return nativeResponseValue;
1425 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
1426 if(!isWasmInitialized) {
1427 throw new Error("initializeWasm() must be awaited first!");
1429 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1430 return nativeResponseValue;
1433 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
1434 if(!isWasmInitialized) {
1435 throw new Error("initializeWasm() must be awaited first!");
1437 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1438 return nativeResponseValue;
1441 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
1442 if(!isWasmInitialized) {
1443 throw new Error("initializeWasm() must be awaited first!");
1445 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1446 return nativeResponseValue;
1449 export class LDKCOption_NetworkUpdateZ {
1450 protected constructor() {}
1453 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
1454 if(!isWasmInitialized) {
1455 throw new Error("initializeWasm() must be awaited first!");
1457 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1458 return nativeResponseValue;
1461 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
1462 if(!isWasmInitialized) {
1463 throw new Error("initializeWasm() must be awaited first!");
1465 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1466 return nativeResponseValue;
1469 export class LDKSpendableOutputDescriptor {
1470 protected constructor() {}
1473 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1474 if(!isWasmInitialized) {
1475 throw new Error("initializeWasm() must be awaited first!");
1477 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1478 return nativeResponseValue;
1481 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1482 if(!isWasmInitialized) {
1483 throw new Error("initializeWasm() must be awaited first!");
1485 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1486 return nativeResponseValue;
1489 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1490 if(!isWasmInitialized) {
1491 throw new Error("initializeWasm() must be awaited first!");
1493 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1494 return nativeResponseValue;
1497 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1498 if(!isWasmInitialized) {
1499 throw new Error("initializeWasm() must be awaited first!");
1501 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1502 return nativeResponseValue;
1505 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1506 if(!isWasmInitialized) {
1507 throw new Error("initializeWasm() must be awaited first!");
1509 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1510 return nativeResponseValue;
1513 export class LDKEvent {
1514 protected constructor() {}
1517 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
1518 if(!isWasmInitialized) {
1519 throw new Error("initializeWasm() must be awaited first!");
1521 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1522 return nativeResponseValue;
1525 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
1526 if(!isWasmInitialized) {
1527 throw new Error("initializeWasm() must be awaited first!");
1529 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1530 return nativeResponseValue;
1533 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
1534 if(!isWasmInitialized) {
1535 throw new Error("initializeWasm() must be awaited first!");
1537 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1538 return nativeResponseValue;
1541 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
1542 if(!isWasmInitialized) {
1543 throw new Error("initializeWasm() must be awaited first!");
1545 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1546 return nativeResponseValue;
1549 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
1550 if(!isWasmInitialized) {
1551 throw new Error("initializeWasm() must be awaited first!");
1553 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1554 return nativeResponseValue;
1557 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): bigint {
1558 if(!isWasmInitialized) {
1559 throw new Error("initializeWasm() must be awaited first!");
1561 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1562 return nativeResponseValue;
1565 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: bigint): number {
1566 if(!isWasmInitialized) {
1567 throw new Error("initializeWasm() must be awaited first!");
1569 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1570 return nativeResponseValue;
1573 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: bigint): bigint {
1574 if(!isWasmInitialized) {
1575 throw new Error("initializeWasm() must be awaited first!");
1577 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1578 return nativeResponseValue;
1581 export function LDKEvent_PaymentReceived_get_purpose(ptr: bigint): bigint {
1582 if(!isWasmInitialized) {
1583 throw new Error("initializeWasm() must be awaited first!");
1585 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1586 return nativeResponseValue;
1589 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
1590 if(!isWasmInitialized) {
1591 throw new Error("initializeWasm() must be awaited first!");
1593 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1594 return nativeResponseValue;
1597 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
1598 if(!isWasmInitialized) {
1599 throw new Error("initializeWasm() must be awaited first!");
1601 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1602 return nativeResponseValue;
1605 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
1606 if(!isWasmInitialized) {
1607 throw new Error("initializeWasm() must be awaited first!");
1609 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1610 return nativeResponseValue;
1613 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): number {
1614 if(!isWasmInitialized) {
1615 throw new Error("initializeWasm() must be awaited first!");
1617 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1618 return nativeResponseValue;
1621 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
1622 if(!isWasmInitialized) {
1623 throw new Error("initializeWasm() must be awaited first!");
1625 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1626 return nativeResponseValue;
1629 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
1630 if(!isWasmInitialized) {
1631 throw new Error("initializeWasm() must be awaited first!");
1633 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1634 return nativeResponseValue;
1637 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
1638 if(!isWasmInitialized) {
1639 throw new Error("initializeWasm() must be awaited first!");
1641 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1642 return nativeResponseValue;
1645 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
1646 if(!isWasmInitialized) {
1647 throw new Error("initializeWasm() must be awaited first!");
1649 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1650 return nativeResponseValue;
1653 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
1654 if(!isWasmInitialized) {
1655 throw new Error("initializeWasm() must be awaited first!");
1657 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1658 return nativeResponseValue;
1661 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
1662 if(!isWasmInitialized) {
1663 throw new Error("initializeWasm() must be awaited first!");
1665 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1666 return nativeResponseValue;
1669 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): number {
1670 if(!isWasmInitialized) {
1671 throw new Error("initializeWasm() must be awaited first!");
1673 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1674 return nativeResponseValue;
1677 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): number {
1678 if(!isWasmInitialized) {
1679 throw new Error("initializeWasm() must be awaited first!");
1681 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1682 return nativeResponseValue;
1685 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): number {
1686 if(!isWasmInitialized) {
1687 throw new Error("initializeWasm() must be awaited first!");
1689 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1690 return nativeResponseValue;
1693 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
1694 if(!isWasmInitialized) {
1695 throw new Error("initializeWasm() must be awaited first!");
1697 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1698 return nativeResponseValue;
1701 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: bigint): boolean {
1702 if(!isWasmInitialized) {
1703 throw new Error("initializeWasm() must be awaited first!");
1705 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1706 return nativeResponseValue;
1709 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: bigint): bigint {
1710 if(!isWasmInitialized) {
1711 throw new Error("initializeWasm() must be awaited first!");
1713 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1714 return nativeResponseValue;
1717 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: bigint): boolean {
1718 if(!isWasmInitialized) {
1719 throw new Error("initializeWasm() must be awaited first!");
1721 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1722 return nativeResponseValue;
1725 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): number {
1726 if(!isWasmInitialized) {
1727 throw new Error("initializeWasm() must be awaited first!");
1729 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1730 return nativeResponseValue;
1733 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
1734 if(!isWasmInitialized) {
1735 throw new Error("initializeWasm() must be awaited first!");
1737 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1738 return nativeResponseValue;
1741 export function LDKEvent_PaymentPathFailed_get_retry(ptr: bigint): bigint {
1742 if(!isWasmInitialized) {
1743 throw new Error("initializeWasm() must be awaited first!");
1745 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1746 return nativeResponseValue;
1749 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
1750 if(!isWasmInitialized) {
1751 throw new Error("initializeWasm() must be awaited first!");
1753 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
1754 return nativeResponseValue;
1757 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
1758 if(!isWasmInitialized) {
1759 throw new Error("initializeWasm() must be awaited first!");
1761 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
1762 return nativeResponseValue;
1765 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): number {
1766 if(!isWasmInitialized) {
1767 throw new Error("initializeWasm() must be awaited first!");
1769 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
1770 return nativeResponseValue;
1773 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
1774 if(!isWasmInitialized) {
1775 throw new Error("initializeWasm() must be awaited first!");
1777 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
1778 return nativeResponseValue;
1781 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
1782 if(!isWasmInitialized) {
1783 throw new Error("initializeWasm() must be awaited first!");
1785 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
1786 return nativeResponseValue;
1789 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): number {
1790 if(!isWasmInitialized) {
1791 throw new Error("initializeWasm() must be awaited first!");
1793 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
1794 return nativeResponseValue;
1797 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
1798 if(!isWasmInitialized) {
1799 throw new Error("initializeWasm() must be awaited first!");
1801 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
1802 return nativeResponseValue;
1805 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
1806 if(!isWasmInitialized) {
1807 throw new Error("initializeWasm() must be awaited first!");
1809 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1810 return nativeResponseValue;
1813 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
1814 if(!isWasmInitialized) {
1815 throw new Error("initializeWasm() must be awaited first!");
1817 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1818 return nativeResponseValue;
1821 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): number {
1822 if(!isWasmInitialized) {
1823 throw new Error("initializeWasm() must be awaited first!");
1825 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1826 return nativeResponseValue;
1829 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): number {
1830 if(!isWasmInitialized) {
1831 throw new Error("initializeWasm() must be awaited first!");
1833 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1834 return nativeResponseValue;
1837 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
1838 if(!isWasmInitialized) {
1839 throw new Error("initializeWasm() must be awaited first!");
1841 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1842 return nativeResponseValue;
1845 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
1846 if(!isWasmInitialized) {
1847 throw new Error("initializeWasm() must be awaited first!");
1849 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1850 return nativeResponseValue;
1853 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
1854 if(!isWasmInitialized) {
1855 throw new Error("initializeWasm() must be awaited first!");
1857 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1858 return nativeResponseValue;
1861 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): bigint {
1862 if(!isWasmInitialized) {
1863 throw new Error("initializeWasm() must be awaited first!");
1865 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1866 return nativeResponseValue;
1869 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
1870 if(!isWasmInitialized) {
1871 throw new Error("initializeWasm() must be awaited first!");
1873 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1874 return nativeResponseValue;
1877 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
1878 if(!isWasmInitialized) {
1879 throw new Error("initializeWasm() must be awaited first!");
1881 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1882 return nativeResponseValue;
1885 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
1886 if(!isWasmInitialized) {
1887 throw new Error("initializeWasm() must be awaited first!");
1889 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1890 return nativeResponseValue;
1893 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
1894 if(!isWasmInitialized) {
1895 throw new Error("initializeWasm() must be awaited first!");
1897 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1898 return nativeResponseValue;
1901 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
1902 if(!isWasmInitialized) {
1903 throw new Error("initializeWasm() must be awaited first!");
1905 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1906 return nativeResponseValue;
1909 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
1910 if(!isWasmInitialized) {
1911 throw new Error("initializeWasm() must be awaited first!");
1913 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1914 return nativeResponseValue;
1917 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
1918 if(!isWasmInitialized) {
1919 throw new Error("initializeWasm() must be awaited first!");
1921 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1922 return nativeResponseValue;
1925 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
1926 if(!isWasmInitialized) {
1927 throw new Error("initializeWasm() must be awaited first!");
1929 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1930 return nativeResponseValue;
1933 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
1934 if(!isWasmInitialized) {
1935 throw new Error("initializeWasm() must be awaited first!");
1937 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
1938 return nativeResponseValue;
1941 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
1946 return nativeResponseValue;
1949 export class LDKCOption_EventZ {
1950 protected constructor() {}
1953 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
1954 if(!isWasmInitialized) {
1955 throw new Error("initializeWasm() must be awaited first!");
1957 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1958 return nativeResponseValue;
1961 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
1962 if(!isWasmInitialized) {
1963 throw new Error("initializeWasm() must be awaited first!");
1965 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1966 return nativeResponseValue;
1968 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1970 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
1971 if(!isWasmInitialized) {
1972 throw new Error("initializeWasm() must be awaited first!");
1974 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1975 return nativeResponseValue;
1977 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1979 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
1980 if(!isWasmInitialized) {
1981 throw new Error("initializeWasm() must be awaited first!");
1983 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1984 return nativeResponseValue;
1987 export class LDKErrorAction {
1988 protected constructor() {}
1991 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
1992 if(!isWasmInitialized) {
1993 throw new Error("initializeWasm() must be awaited first!");
1995 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1996 return nativeResponseValue;
1999 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
2000 if(!isWasmInitialized) {
2001 throw new Error("initializeWasm() must be awaited first!");
2003 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2004 return nativeResponseValue;
2007 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
2008 if(!isWasmInitialized) {
2009 throw new Error("initializeWasm() must be awaited first!");
2011 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2012 return nativeResponseValue;
2015 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
2016 if(!isWasmInitialized) {
2017 throw new Error("initializeWasm() must be awaited first!");
2019 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2020 return nativeResponseValue;
2023 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
2024 if(!isWasmInitialized) {
2025 throw new Error("initializeWasm() must be awaited first!");
2027 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2028 return nativeResponseValue;
2031 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
2032 if(!isWasmInitialized) {
2033 throw new Error("initializeWasm() must be awaited first!");
2035 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2036 return nativeResponseValue;
2039 export class LDKMessageSendEvent {
2040 protected constructor() {}
2043 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
2044 if(!isWasmInitialized) {
2045 throw new Error("initializeWasm() must be awaited first!");
2047 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2048 return nativeResponseValue;
2051 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
2052 if(!isWasmInitialized) {
2053 throw new Error("initializeWasm() must be awaited first!");
2055 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2056 return nativeResponseValue;
2059 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
2060 if(!isWasmInitialized) {
2061 throw new Error("initializeWasm() must be awaited first!");
2063 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2064 return nativeResponseValue;
2067 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
2068 if(!isWasmInitialized) {
2069 throw new Error("initializeWasm() must be awaited first!");
2071 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2072 return nativeResponseValue;
2075 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
2076 if(!isWasmInitialized) {
2077 throw new Error("initializeWasm() must be awaited first!");
2079 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2080 return nativeResponseValue;
2083 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
2084 if(!isWasmInitialized) {
2085 throw new Error("initializeWasm() must be awaited first!");
2087 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2088 return nativeResponseValue;
2091 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
2092 if(!isWasmInitialized) {
2093 throw new Error("initializeWasm() must be awaited first!");
2095 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2096 return nativeResponseValue;
2099 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
2100 if(!isWasmInitialized) {
2101 throw new Error("initializeWasm() must be awaited first!");
2103 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2104 return nativeResponseValue;
2107 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
2108 if(!isWasmInitialized) {
2109 throw new Error("initializeWasm() must be awaited first!");
2111 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2112 return nativeResponseValue;
2115 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
2116 if(!isWasmInitialized) {
2117 throw new Error("initializeWasm() must be awaited first!");
2119 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2120 return nativeResponseValue;
2123 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
2124 if(!isWasmInitialized) {
2125 throw new Error("initializeWasm() must be awaited first!");
2127 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2128 return nativeResponseValue;
2131 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
2132 if(!isWasmInitialized) {
2133 throw new Error("initializeWasm() must be awaited first!");
2135 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2136 return nativeResponseValue;
2139 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
2140 if(!isWasmInitialized) {
2141 throw new Error("initializeWasm() must be awaited first!");
2143 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2144 return nativeResponseValue;
2147 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
2148 if(!isWasmInitialized) {
2149 throw new Error("initializeWasm() must be awaited first!");
2151 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2152 return nativeResponseValue;
2155 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
2156 if(!isWasmInitialized) {
2157 throw new Error("initializeWasm() must be awaited first!");
2159 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2160 return nativeResponseValue;
2163 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
2164 if(!isWasmInitialized) {
2165 throw new Error("initializeWasm() must be awaited first!");
2167 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2168 return nativeResponseValue;
2171 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
2172 if(!isWasmInitialized) {
2173 throw new Error("initializeWasm() must be awaited first!");
2175 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2176 return nativeResponseValue;
2179 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
2180 if(!isWasmInitialized) {
2181 throw new Error("initializeWasm() must be awaited first!");
2183 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2184 return nativeResponseValue;
2187 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
2188 if(!isWasmInitialized) {
2189 throw new Error("initializeWasm() must be awaited first!");
2191 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2192 return nativeResponseValue;
2195 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
2196 if(!isWasmInitialized) {
2197 throw new Error("initializeWasm() must be awaited first!");
2199 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2200 return nativeResponseValue;
2203 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
2204 if(!isWasmInitialized) {
2205 throw new Error("initializeWasm() must be awaited first!");
2207 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2208 return nativeResponseValue;
2211 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
2212 if(!isWasmInitialized) {
2213 throw new Error("initializeWasm() must be awaited first!");
2215 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2216 return nativeResponseValue;
2219 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
2220 if(!isWasmInitialized) {
2221 throw new Error("initializeWasm() must be awaited first!");
2223 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2224 return nativeResponseValue;
2227 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
2228 if(!isWasmInitialized) {
2229 throw new Error("initializeWasm() must be awaited first!");
2231 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2232 return nativeResponseValue;
2235 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
2236 if(!isWasmInitialized) {
2237 throw new Error("initializeWasm() must be awaited first!");
2239 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2240 return nativeResponseValue;
2243 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
2244 if(!isWasmInitialized) {
2245 throw new Error("initializeWasm() must be awaited first!");
2247 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2248 return nativeResponseValue;
2251 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
2252 if(!isWasmInitialized) {
2253 throw new Error("initializeWasm() must be awaited first!");
2255 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2256 return nativeResponseValue;
2259 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
2260 if(!isWasmInitialized) {
2261 throw new Error("initializeWasm() must be awaited first!");
2263 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2264 return nativeResponseValue;
2267 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
2268 if(!isWasmInitialized) {
2269 throw new Error("initializeWasm() must be awaited first!");
2271 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2272 return nativeResponseValue;
2275 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
2276 if(!isWasmInitialized) {
2277 throw new Error("initializeWasm() must be awaited first!");
2279 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2280 return nativeResponseValue;
2283 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
2284 if(!isWasmInitialized) {
2285 throw new Error("initializeWasm() must be awaited first!");
2287 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2288 return nativeResponseValue;
2291 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
2292 if(!isWasmInitialized) {
2293 throw new Error("initializeWasm() must be awaited first!");
2295 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2296 return nativeResponseValue;
2299 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
2300 if(!isWasmInitialized) {
2301 throw new Error("initializeWasm() must be awaited first!");
2303 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2304 return nativeResponseValue;
2307 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
2308 if(!isWasmInitialized) {
2309 throw new Error("initializeWasm() must be awaited first!");
2311 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2312 return nativeResponseValue;
2315 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
2316 if(!isWasmInitialized) {
2317 throw new Error("initializeWasm() must be awaited first!");
2319 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2320 return nativeResponseValue;
2323 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
2324 if(!isWasmInitialized) {
2325 throw new Error("initializeWasm() must be awaited first!");
2327 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2328 return nativeResponseValue;
2331 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
2332 if(!isWasmInitialized) {
2333 throw new Error("initializeWasm() must be awaited first!");
2335 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2336 return nativeResponseValue;
2339 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
2340 if(!isWasmInitialized) {
2341 throw new Error("initializeWasm() must be awaited first!");
2343 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2344 return nativeResponseValue;
2347 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
2348 if(!isWasmInitialized) {
2349 throw new Error("initializeWasm() must be awaited first!");
2351 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2352 return nativeResponseValue;
2354 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2356 export function CResult_TxOutAccessErrorZ_get_ok(owner: bigint): bigint {
2357 if(!isWasmInitialized) {
2358 throw new Error("initializeWasm() must be awaited first!");
2360 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2361 return nativeResponseValue;
2363 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2365 export function CResult_TxOutAccessErrorZ_get_err(owner: bigint): AccessError {
2366 if(!isWasmInitialized) {
2367 throw new Error("initializeWasm() must be awaited first!");
2369 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2370 return nativeResponseValue;
2372 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2374 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2375 if(!isWasmInitialized) {
2376 throw new Error("initializeWasm() must be awaited first!");
2378 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2379 return nativeResponseValue;
2381 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2383 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2384 if(!isWasmInitialized) {
2385 throw new Error("initializeWasm() must be awaited first!");
2387 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2388 return nativeResponseValue;
2390 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2392 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: bigint): void {
2393 if(!isWasmInitialized) {
2394 throw new Error("initializeWasm() must be awaited first!");
2396 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2397 // debug statements here
2399 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2401 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: bigint): ChannelMonitorUpdateErr {
2402 if(!isWasmInitialized) {
2403 throw new Error("initializeWasm() must be awaited first!");
2405 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2406 return nativeResponseValue;
2409 export class LDKMonitorEvent {
2410 protected constructor() {}
2413 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2414 if(!isWasmInitialized) {
2415 throw new Error("initializeWasm() must be awaited first!");
2417 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2418 return nativeResponseValue;
2421 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2422 if(!isWasmInitialized) {
2423 throw new Error("initializeWasm() must be awaited first!");
2425 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2426 return nativeResponseValue;
2429 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: bigint): bigint {
2430 if(!isWasmInitialized) {
2431 throw new Error("initializeWasm() must be awaited first!");
2433 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2434 return nativeResponseValue;
2437 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: bigint): bigint {
2438 if(!isWasmInitialized) {
2439 throw new Error("initializeWasm() must be awaited first!");
2441 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2442 return nativeResponseValue;
2445 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: bigint): bigint {
2446 if(!isWasmInitialized) {
2447 throw new Error("initializeWasm() must be awaited first!");
2449 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2450 return nativeResponseValue;
2453 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: bigint): bigint {
2454 if(!isWasmInitialized) {
2455 throw new Error("initializeWasm() must be awaited first!");
2457 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2458 return nativeResponseValue;
2460 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2462 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2463 if(!isWasmInitialized) {
2464 throw new Error("initializeWasm() must be awaited first!");
2466 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2467 return nativeResponseValue;
2469 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2471 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2472 if(!isWasmInitialized) {
2473 throw new Error("initializeWasm() must be awaited first!");
2475 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2476 return nativeResponseValue;
2478 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2480 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2481 if(!isWasmInitialized) {
2482 throw new Error("initializeWasm() must be awaited first!");
2484 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2485 return nativeResponseValue;
2488 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2489 protected constructor() {}
2492 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: bigint): number {
2493 if(!isWasmInitialized) {
2494 throw new Error("initializeWasm() must be awaited first!");
2496 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2497 return nativeResponseValue;
2500 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: bigint): bigint {
2501 if(!isWasmInitialized) {
2502 throw new Error("initializeWasm() must be awaited first!");
2504 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2505 return nativeResponseValue;
2507 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2509 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2510 if(!isWasmInitialized) {
2511 throw new Error("initializeWasm() must be awaited first!");
2513 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2514 return nativeResponseValue;
2516 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2518 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2519 if(!isWasmInitialized) {
2520 throw new Error("initializeWasm() must be awaited first!");
2522 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2523 return nativeResponseValue;
2525 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2527 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2528 if(!isWasmInitialized) {
2529 throw new Error("initializeWasm() must be awaited first!");
2531 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2532 return nativeResponseValue;
2534 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2536 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2537 if(!isWasmInitialized) {
2538 throw new Error("initializeWasm() must be awaited first!");
2540 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2541 return nativeResponseValue;
2544 export class LDKCOption_C2Tuple_u64u64ZZ {
2545 protected constructor() {}
2548 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2549 if(!isWasmInitialized) {
2550 throw new Error("initializeWasm() must be awaited first!");
2552 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2553 return nativeResponseValue;
2556 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2557 if(!isWasmInitialized) {
2558 throw new Error("initializeWasm() must be awaited first!");
2560 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2561 return nativeResponseValue;
2564 export interface LDKLogger {
2565 log (record: bigint): void;
2569 export function LDKLogger_new(impl: LDKLogger): bigint {
2570 if(!isWasmInitialized) {
2571 throw new Error("initializeWasm() must be awaited first!");
2573 var new_obj_idx = js_objs.length;
2574 for (var i = 0; i < js_objs.length; i++) {
2575 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2577 js_objs[i] = new WeakRef(impl);
2578 return wasm.TS_LDKLogger_new(i);
2580 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2582 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2583 if(!isWasmInitialized) {
2584 throw new Error("initializeWasm() must be awaited first!");
2586 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2587 return nativeResponseValue;
2589 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2591 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2592 if(!isWasmInitialized) {
2593 throw new Error("initializeWasm() must be awaited first!");
2595 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2596 return nativeResponseValue;
2598 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2600 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2601 if(!isWasmInitialized) {
2602 throw new Error("initializeWasm() must be awaited first!");
2604 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2605 return nativeResponseValue;
2607 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2609 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2610 if(!isWasmInitialized) {
2611 throw new Error("initializeWasm() must be awaited first!");
2613 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2614 return nativeResponseValue;
2616 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2618 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2619 if(!isWasmInitialized) {
2620 throw new Error("initializeWasm() must be awaited first!");
2622 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2623 return nativeResponseValue;
2625 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2627 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2628 if(!isWasmInitialized) {
2629 throw new Error("initializeWasm() must be awaited first!");
2631 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2632 return nativeResponseValue;
2634 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2636 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2637 if(!isWasmInitialized) {
2638 throw new Error("initializeWasm() must be awaited first!");
2640 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2641 return nativeResponseValue;
2643 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2645 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2646 if(!isWasmInitialized) {
2647 throw new Error("initializeWasm() must be awaited first!");
2649 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2650 return nativeResponseValue;
2652 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2654 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2655 if(!isWasmInitialized) {
2656 throw new Error("initializeWasm() must be awaited first!");
2658 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2659 return nativeResponseValue;
2661 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2663 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2664 if(!isWasmInitialized) {
2665 throw new Error("initializeWasm() must be awaited first!");
2667 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2668 return nativeResponseValue;
2670 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2672 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2673 if(!isWasmInitialized) {
2674 throw new Error("initializeWasm() must be awaited first!");
2676 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2677 return nativeResponseValue;
2679 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2681 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2682 if(!isWasmInitialized) {
2683 throw new Error("initializeWasm() must be awaited first!");
2685 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2686 return nativeResponseValue;
2688 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2690 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
2691 if(!isWasmInitialized) {
2692 throw new Error("initializeWasm() must be awaited first!");
2694 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2695 return nativeResponseValue;
2697 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2699 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
2700 if(!isWasmInitialized) {
2701 throw new Error("initializeWasm() must be awaited first!");
2703 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2704 return nativeResponseValue;
2706 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2708 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
2709 if(!isWasmInitialized) {
2710 throw new Error("initializeWasm() must be awaited first!");
2712 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2713 return nativeResponseValue;
2715 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2717 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
2718 if(!isWasmInitialized) {
2719 throw new Error("initializeWasm() must be awaited first!");
2721 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2722 return nativeResponseValue;
2725 export interface LDKAccess {
2726 get_utxo (genesis_hash: number, short_channel_id: bigint): bigint;
2730 export function LDKAccess_new(impl: LDKAccess): bigint {
2731 if(!isWasmInitialized) {
2732 throw new Error("initializeWasm() must be awaited first!");
2734 var new_obj_idx = js_objs.length;
2735 for (var i = 0; i < js_objs.length; i++) {
2736 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2738 js_objs[i] = new WeakRef(impl);
2739 return wasm.TS_LDKAccess_new(i);
2741 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2743 export function Access_get_utxo(this_arg: bigint, genesis_hash: number, short_channel_id: bigint): bigint {
2744 if(!isWasmInitialized) {
2745 throw new Error("initializeWasm() must be awaited first!");
2747 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2748 return nativeResponseValue;
2751 export class LDKCOption_AccessZ {
2752 protected constructor() {}
2755 export function LDKCOption_AccessZ_ty_from_ptr(ptr: bigint): number {
2756 if(!isWasmInitialized) {
2757 throw new Error("initializeWasm() must be awaited first!");
2759 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2760 return nativeResponseValue;
2763 export function LDKCOption_AccessZ_Some_get_some(ptr: bigint): bigint {
2764 if(!isWasmInitialized) {
2765 throw new Error("initializeWasm() must be awaited first!");
2767 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2768 return nativeResponseValue;
2770 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2772 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
2773 if(!isWasmInitialized) {
2774 throw new Error("initializeWasm() must be awaited first!");
2776 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2777 return nativeResponseValue;
2779 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2781 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
2782 if(!isWasmInitialized) {
2783 throw new Error("initializeWasm() must be awaited first!");
2785 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2786 return nativeResponseValue;
2788 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2790 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
2791 if(!isWasmInitialized) {
2792 throw new Error("initializeWasm() must be awaited first!");
2794 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2795 return nativeResponseValue;
2797 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2799 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
2800 if(!isWasmInitialized) {
2801 throw new Error("initializeWasm() must be awaited first!");
2803 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2804 return nativeResponseValue;
2806 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2808 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
2809 if(!isWasmInitialized) {
2810 throw new Error("initializeWasm() must be awaited first!");
2812 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2813 return nativeResponseValue;
2815 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2817 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
2818 if(!isWasmInitialized) {
2819 throw new Error("initializeWasm() must be awaited first!");
2821 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2822 // debug statements here
2824 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2826 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
2827 if(!isWasmInitialized) {
2828 throw new Error("initializeWasm() must be awaited first!");
2830 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2831 return nativeResponseValue;
2833 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2835 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2836 if(!isWasmInitialized) {
2837 throw new Error("initializeWasm() must be awaited first!");
2839 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2840 return nativeResponseValue;
2842 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2844 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2845 if(!isWasmInitialized) {
2846 throw new Error("initializeWasm() must be awaited first!");
2848 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2849 return nativeResponseValue;
2851 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2853 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2854 if(!isWasmInitialized) {
2855 throw new Error("initializeWasm() must be awaited first!");
2857 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2858 return nativeResponseValue;
2860 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2862 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2863 if(!isWasmInitialized) {
2864 throw new Error("initializeWasm() must be awaited first!");
2866 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2867 return nativeResponseValue;
2869 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2871 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
2872 if(!isWasmInitialized) {
2873 throw new Error("initializeWasm() must be awaited first!");
2875 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2876 return nativeResponseValue;
2878 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2880 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
2881 if(!isWasmInitialized) {
2882 throw new Error("initializeWasm() must be awaited first!");
2884 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2885 return nativeResponseValue;
2888 export class LDKNetAddress {
2889 protected constructor() {}
2892 export function LDKNetAddress_ty_from_ptr(ptr: bigint): number {
2893 if(!isWasmInitialized) {
2894 throw new Error("initializeWasm() must be awaited first!");
2896 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2897 return nativeResponseValue;
2900 export function LDKNetAddress_IPv4_get_addr(ptr: bigint): number {
2901 if(!isWasmInitialized) {
2902 throw new Error("initializeWasm() must be awaited first!");
2904 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2905 return nativeResponseValue;
2908 export function LDKNetAddress_IPv4_get_port(ptr: bigint): number {
2909 if(!isWasmInitialized) {
2910 throw new Error("initializeWasm() must be awaited first!");
2912 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2913 return nativeResponseValue;
2916 export function LDKNetAddress_IPv6_get_addr(ptr: bigint): number {
2917 if(!isWasmInitialized) {
2918 throw new Error("initializeWasm() must be awaited first!");
2920 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2921 return nativeResponseValue;
2924 export function LDKNetAddress_IPv6_get_port(ptr: bigint): number {
2925 if(!isWasmInitialized) {
2926 throw new Error("initializeWasm() must be awaited first!");
2928 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2929 return nativeResponseValue;
2932 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: bigint): number {
2933 if(!isWasmInitialized) {
2934 throw new Error("initializeWasm() must be awaited first!");
2936 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2937 return nativeResponseValue;
2940 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
2941 if(!isWasmInitialized) {
2942 throw new Error("initializeWasm() must be awaited first!");
2944 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2945 return nativeResponseValue;
2948 export function LDKNetAddress_OnionV3_get_checksum(ptr: bigint): number {
2949 if(!isWasmInitialized) {
2950 throw new Error("initializeWasm() must be awaited first!");
2952 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2953 return nativeResponseValue;
2956 export function LDKNetAddress_OnionV3_get_version(ptr: bigint): number {
2957 if(!isWasmInitialized) {
2958 throw new Error("initializeWasm() must be awaited first!");
2960 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2961 return nativeResponseValue;
2964 export function LDKNetAddress_OnionV3_get_port(ptr: bigint): number {
2965 if(!isWasmInitialized) {
2966 throw new Error("initializeWasm() must be awaited first!");
2968 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2969 return nativeResponseValue;
2972 export function LDKNetAddress_Hostname_get_hostname(ptr: bigint): bigint {
2973 if(!isWasmInitialized) {
2974 throw new Error("initializeWasm() must be awaited first!");
2976 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
2977 return nativeResponseValue;
2980 export function LDKNetAddress_Hostname_get_port(ptr: bigint): number {
2981 if(!isWasmInitialized) {
2982 throw new Error("initializeWasm() must be awaited first!");
2984 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
2985 return nativeResponseValue;
2987 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2989 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
2990 if(!isWasmInitialized) {
2991 throw new Error("initializeWasm() must be awaited first!");
2993 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2994 return nativeResponseValue;
2996 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2998 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
2999 if(!isWasmInitialized) {
3000 throw new Error("initializeWasm() must be awaited first!");
3002 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3003 return nativeResponseValue;
3005 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3007 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3008 if(!isWasmInitialized) {
3009 throw new Error("initializeWasm() must be awaited first!");
3011 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3012 return nativeResponseValue;
3014 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3016 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3017 if(!isWasmInitialized) {
3018 throw new Error("initializeWasm() must be awaited first!");
3020 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3021 return nativeResponseValue;
3023 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3025 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3026 if(!isWasmInitialized) {
3027 throw new Error("initializeWasm() must be awaited first!");
3029 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3030 return nativeResponseValue;
3032 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3034 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3035 if(!isWasmInitialized) {
3036 throw new Error("initializeWasm() must be awaited first!");
3038 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3039 return nativeResponseValue;
3041 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3043 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3044 if(!isWasmInitialized) {
3045 throw new Error("initializeWasm() must be awaited first!");
3047 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3048 return nativeResponseValue;
3050 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3052 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3053 if(!isWasmInitialized) {
3054 throw new Error("initializeWasm() must be awaited first!");
3056 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3057 return nativeResponseValue;
3060 export class LDKCOption_CVec_NetAddressZZ {
3061 protected constructor() {}
3064 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: bigint): number {
3065 if(!isWasmInitialized) {
3066 throw new Error("initializeWasm() must be awaited first!");
3068 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3069 return nativeResponseValue;
3072 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: bigint): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3077 return nativeResponseValue;
3079 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3081 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3086 return nativeResponseValue;
3088 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3090 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3095 return nativeResponseValue;
3097 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3099 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3104 return nativeResponseValue;
3106 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3108 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3113 return nativeResponseValue;
3115 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3117 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3122 return nativeResponseValue;
3124 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3126 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3131 return nativeResponseValue;
3133 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3135 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: bigint): number {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3140 return nativeResponseValue;
3142 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3144 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: bigint): number {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3149 return nativeResponseValue;
3151 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3153 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: bigint): bigint {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3158 return nativeResponseValue;
3160 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3162 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: bigint): void {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3167 // debug statements here
3169 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3171 export function CResult_SignatureNoneZ_get_ok(owner: bigint): number {
3172 if(!isWasmInitialized) {
3173 throw new Error("initializeWasm() must be awaited first!");
3175 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3176 return nativeResponseValue;
3178 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3180 export function CResult_SignatureNoneZ_get_err(owner: bigint): void {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3185 // debug statements here
3187 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3189 export function C2Tuple_SignatureSignatureZ_get_a(owner: bigint): number {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
3194 return nativeResponseValue;
3196 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3198 export function C2Tuple_SignatureSignatureZ_get_b(owner: bigint): number {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
3203 return nativeResponseValue;
3205 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3207 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: bigint): bigint {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3212 return nativeResponseValue;
3214 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3216 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: bigint): void {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3221 // debug statements here
3223 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3225 export function CResult_SecretKeyNoneZ_get_ok(owner: bigint): number {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3230 return nativeResponseValue;
3232 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3234 export function CResult_SecretKeyNoneZ_get_err(owner: bigint): void {
3235 if(!isWasmInitialized) {
3236 throw new Error("initializeWasm() must be awaited first!");
3238 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3239 // debug statements here
3242 export interface LDKBaseSign {
3243 get_per_commitment_point (idx: bigint): number;
3244 release_commitment_secret (idx: bigint): number;
3245 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
3246 channel_keys_id (): number;
3247 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
3248 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
3249 sign_holder_commitment_and_htlcs (commitment_tx: bigint): bigint;
3250 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
3251 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
3252 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
3253 sign_closing_transaction (closing_tx: bigint): bigint;
3254 sign_channel_announcement (msg: bigint): bigint;
3255 ready_channel (channel_parameters: bigint): void;
3259 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: bigint): bigint {
3260 if(!isWasmInitialized) {
3261 throw new Error("initializeWasm() must be awaited first!");
3263 var new_obj_idx = js_objs.length;
3264 for (var i = 0; i < js_objs.length; i++) {
3265 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3267 js_objs[i] = new WeakRef(impl);
3268 return wasm.TS_LDKBaseSign_new(i);
3270 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3272 export function BaseSign_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
3273 if(!isWasmInitialized) {
3274 throw new Error("initializeWasm() must be awaited first!");
3276 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3277 return nativeResponseValue;
3279 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3281 export function BaseSign_release_commitment_secret(this_arg: bigint, idx: bigint): number {
3282 if(!isWasmInitialized) {
3283 throw new Error("initializeWasm() must be awaited first!");
3285 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3286 return nativeResponseValue;
3288 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3290 export function BaseSign_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
3291 if(!isWasmInitialized) {
3292 throw new Error("initializeWasm() must be awaited first!");
3294 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3295 return nativeResponseValue;
3297 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3299 export function BaseSign_channel_keys_id(this_arg: bigint): number {
3300 if(!isWasmInitialized) {
3301 throw new Error("initializeWasm() must be awaited first!");
3303 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3304 return nativeResponseValue;
3306 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3308 export function BaseSign_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
3309 if(!isWasmInitialized) {
3310 throw new Error("initializeWasm() must be awaited first!");
3312 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3313 return nativeResponseValue;
3315 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3317 export function BaseSign_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
3318 if(!isWasmInitialized) {
3319 throw new Error("initializeWasm() must be awaited first!");
3321 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3322 return nativeResponseValue;
3324 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3326 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: bigint, commitment_tx: bigint): bigint {
3327 if(!isWasmInitialized) {
3328 throw new Error("initializeWasm() must be awaited first!");
3330 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3331 return nativeResponseValue;
3333 // LDKCResult_SignatureNoneZ BaseSign_sign_justice_revoked_output LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]
3335 export function BaseSign_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
3336 if(!isWasmInitialized) {
3337 throw new Error("initializeWasm() must be awaited first!");
3339 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3340 return nativeResponseValue;
3342 // LDKCResult_SignatureNoneZ BaseSign_sign_justice_revoked_htlc LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
3344 export function BaseSign_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
3345 if(!isWasmInitialized) {
3346 throw new Error("initializeWasm() must be awaited first!");
3348 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3349 return nativeResponseValue;
3351 // LDKCResult_SignatureNoneZ BaseSign_sign_counterparty_htlc_transaction LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
3353 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
3354 if(!isWasmInitialized) {
3355 throw new Error("initializeWasm() must be awaited first!");
3357 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3358 return nativeResponseValue;
3360 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3362 export function BaseSign_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
3363 if(!isWasmInitialized) {
3364 throw new Error("initializeWasm() must be awaited first!");
3366 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3367 return nativeResponseValue;
3369 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3371 export function BaseSign_sign_channel_announcement(this_arg: bigint, msg: bigint): bigint {
3372 if(!isWasmInitialized) {
3373 throw new Error("initializeWasm() must be awaited first!");
3375 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3376 return nativeResponseValue;
3378 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3380 export function BaseSign_ready_channel(this_arg: bigint, channel_parameters: bigint): void {
3381 if(!isWasmInitialized) {
3382 throw new Error("initializeWasm() must be awaited first!");
3384 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3385 // debug statements here
3387 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3389 export function BaseSign_get_pubkeys(this_arg: bigint): bigint {
3390 if(!isWasmInitialized) {
3391 throw new Error("initializeWasm() must be awaited first!");
3393 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3394 return nativeResponseValue;
3397 export interface LDKSign {
3402 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: bigint): bigint {
3403 if(!isWasmInitialized) {
3404 throw new Error("initializeWasm() must be awaited first!");
3406 var new_obj_idx = js_objs.length;
3407 for (var i = 0; i < js_objs.length; i++) {
3408 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3410 js_objs[i] = new WeakRef(impl);
3411 return wasm.TS_LDKSign_new(i);
3413 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3415 export function Sign_write(this_arg: bigint): number {
3416 if(!isWasmInitialized) {
3417 throw new Error("initializeWasm() must be awaited first!");
3419 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3420 return nativeResponseValue;
3422 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3424 export function CResult_SignDecodeErrorZ_get_ok(owner: bigint): bigint {
3425 if(!isWasmInitialized) {
3426 throw new Error("initializeWasm() must be awaited first!");
3428 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3429 return nativeResponseValue;
3431 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3433 export function CResult_SignDecodeErrorZ_get_err(owner: bigint): bigint {
3434 if(!isWasmInitialized) {
3435 throw new Error("initializeWasm() must be awaited first!");
3437 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3438 return nativeResponseValue;
3440 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3442 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
3443 if(!isWasmInitialized) {
3444 throw new Error("initializeWasm() must be awaited first!");
3446 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3447 return nativeResponseValue;
3449 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3451 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
3452 if(!isWasmInitialized) {
3453 throw new Error("initializeWasm() must be awaited first!");
3455 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3456 // debug statements here
3458 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3460 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
3461 if(!isWasmInitialized) {
3462 throw new Error("initializeWasm() must be awaited first!");
3464 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3465 return nativeResponseValue;
3467 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3469 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
3470 if(!isWasmInitialized) {
3471 throw new Error("initializeWasm() must be awaited first!");
3473 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3474 // debug statements here
3476 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3478 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
3479 if(!isWasmInitialized) {
3480 throw new Error("initializeWasm() must be awaited first!");
3482 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3483 return nativeResponseValue;
3485 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3487 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
3488 if(!isWasmInitialized) {
3489 throw new Error("initializeWasm() must be awaited first!");
3491 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3492 return nativeResponseValue;
3494 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3496 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
3497 if(!isWasmInitialized) {
3498 throw new Error("initializeWasm() must be awaited first!");
3500 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3501 return nativeResponseValue;
3503 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3505 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
3506 if(!isWasmInitialized) {
3507 throw new Error("initializeWasm() must be awaited first!");
3509 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3510 // debug statements here
3513 export class LDKCOption_u16Z {
3514 protected constructor() {}
3517 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
3518 if(!isWasmInitialized) {
3519 throw new Error("initializeWasm() must be awaited first!");
3521 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3522 return nativeResponseValue;
3525 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
3526 if(!isWasmInitialized) {
3527 throw new Error("initializeWasm() must be awaited first!");
3529 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3530 return nativeResponseValue;
3533 export class LDKAPIError {
3534 protected constructor() {}
3537 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
3538 if(!isWasmInitialized) {
3539 throw new Error("initializeWasm() must be awaited first!");
3541 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3542 return nativeResponseValue;
3545 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
3546 if(!isWasmInitialized) {
3547 throw new Error("initializeWasm() must be awaited first!");
3549 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3550 return nativeResponseValue;
3553 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
3554 if(!isWasmInitialized) {
3555 throw new Error("initializeWasm() must be awaited first!");
3557 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3558 return nativeResponseValue;
3561 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
3562 if(!isWasmInitialized) {
3563 throw new Error("initializeWasm() must be awaited first!");
3565 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3566 return nativeResponseValue;
3569 export function LDKAPIError_RouteError_get_err(ptr: bigint): number {
3570 if(!isWasmInitialized) {
3571 throw new Error("initializeWasm() must be awaited first!");
3573 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3574 return nativeResponseValue;
3577 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
3578 if(!isWasmInitialized) {
3579 throw new Error("initializeWasm() must be awaited first!");
3581 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3582 return nativeResponseValue;
3585 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
3586 if(!isWasmInitialized) {
3587 throw new Error("initializeWasm() must be awaited first!");
3589 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3590 return nativeResponseValue;
3592 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3594 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
3595 if(!isWasmInitialized) {
3596 throw new Error("initializeWasm() must be awaited first!");
3598 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3599 // debug statements here
3601 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3603 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
3604 if(!isWasmInitialized) {
3605 throw new Error("initializeWasm() must be awaited first!");
3607 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3608 return nativeResponseValue;
3610 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3612 export function CResult__u832APIErrorZ_get_ok(owner: bigint): number {
3613 if(!isWasmInitialized) {
3614 throw new Error("initializeWasm() must be awaited first!");
3616 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3617 return nativeResponseValue;
3619 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3621 export function CResult__u832APIErrorZ_get_err(owner: bigint): bigint {
3622 if(!isWasmInitialized) {
3623 throw new Error("initializeWasm() must be awaited first!");
3625 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3626 return nativeResponseValue;
3629 export class LDKPaymentSendFailure {
3630 protected constructor() {}
3633 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
3634 if(!isWasmInitialized) {
3635 throw new Error("initializeWasm() must be awaited first!");
3637 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3638 return nativeResponseValue;
3641 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
3642 if(!isWasmInitialized) {
3643 throw new Error("initializeWasm() must be awaited first!");
3645 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3646 return nativeResponseValue;
3649 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
3650 if(!isWasmInitialized) {
3651 throw new Error("initializeWasm() must be awaited first!");
3653 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3654 return nativeResponseValue;
3657 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: bigint): number {
3658 if(!isWasmInitialized) {
3659 throw new Error("initializeWasm() must be awaited first!");
3661 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3662 return nativeResponseValue;
3665 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
3666 if(!isWasmInitialized) {
3667 throw new Error("initializeWasm() must be awaited first!");
3669 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3670 return nativeResponseValue;
3673 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
3674 if(!isWasmInitialized) {
3675 throw new Error("initializeWasm() must be awaited first!");
3677 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3678 return nativeResponseValue;
3681 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
3682 if(!isWasmInitialized) {
3683 throw new Error("initializeWasm() must be awaited first!");
3685 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3686 return nativeResponseValue;
3688 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3690 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: bigint): number {
3691 if(!isWasmInitialized) {
3692 throw new Error("initializeWasm() must be awaited first!");
3694 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3695 return nativeResponseValue;
3697 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3699 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: bigint): bigint {
3700 if(!isWasmInitialized) {
3701 throw new Error("initializeWasm() must be awaited first!");
3703 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3704 return nativeResponseValue;
3706 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3708 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
3709 if(!isWasmInitialized) {
3710 throw new Error("initializeWasm() must be awaited first!");
3712 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3713 // debug statements here
3715 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3717 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
3718 if(!isWasmInitialized) {
3719 throw new Error("initializeWasm() must be awaited first!");
3721 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3722 return nativeResponseValue;
3724 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3726 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: bigint): number {
3727 if(!isWasmInitialized) {
3728 throw new Error("initializeWasm() must be awaited first!");
3730 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3731 return nativeResponseValue;
3733 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3735 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: bigint): number {
3736 if(!isWasmInitialized) {
3737 throw new Error("initializeWasm() must be awaited first!");
3739 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3740 return nativeResponseValue;
3742 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3744 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
3745 if(!isWasmInitialized) {
3746 throw new Error("initializeWasm() must be awaited first!");
3748 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3749 return nativeResponseValue;
3751 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3753 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: bigint): bigint {
3754 if(!isWasmInitialized) {
3755 throw new Error("initializeWasm() must be awaited first!");
3757 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3758 return nativeResponseValue;
3760 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3762 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: bigint): number {
3763 if(!isWasmInitialized) {
3764 throw new Error("initializeWasm() must be awaited first!");
3766 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3767 return nativeResponseValue;
3769 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3771 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: bigint): number {
3772 if(!isWasmInitialized) {
3773 throw new Error("initializeWasm() must be awaited first!");
3775 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3776 return nativeResponseValue;
3778 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3780 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: bigint): bigint {
3781 if(!isWasmInitialized) {
3782 throw new Error("initializeWasm() must be awaited first!");
3784 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3785 return nativeResponseValue;
3787 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3789 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: bigint): void {
3790 if(!isWasmInitialized) {
3791 throw new Error("initializeWasm() must be awaited first!");
3793 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3794 // debug statements here
3796 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3798 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: bigint): bigint {
3799 if(!isWasmInitialized) {
3800 throw new Error("initializeWasm() must be awaited first!");
3802 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3803 return nativeResponseValue;
3805 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3807 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: bigint): bigint {
3808 if(!isWasmInitialized) {
3809 throw new Error("initializeWasm() must be awaited first!");
3811 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3812 return nativeResponseValue;
3814 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3816 export function CResult_PaymentSecretNoneZ_get_ok(owner: bigint): number {
3817 if(!isWasmInitialized) {
3818 throw new Error("initializeWasm() must be awaited first!");
3820 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3821 return nativeResponseValue;
3823 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3825 export function CResult_PaymentSecretNoneZ_get_err(owner: bigint): void {
3826 if(!isWasmInitialized) {
3827 throw new Error("initializeWasm() must be awaited first!");
3829 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3830 // debug statements here
3832 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3834 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: bigint): number {
3835 if(!isWasmInitialized) {
3836 throw new Error("initializeWasm() must be awaited first!");
3838 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3839 return nativeResponseValue;
3841 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3843 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: bigint): bigint {
3844 if(!isWasmInitialized) {
3845 throw new Error("initializeWasm() must be awaited first!");
3847 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3848 return nativeResponseValue;
3850 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3852 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: bigint): number {
3853 if(!isWasmInitialized) {
3854 throw new Error("initializeWasm() must be awaited first!");
3856 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3857 return nativeResponseValue;
3859 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3861 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: bigint): bigint {
3862 if(!isWasmInitialized) {
3863 throw new Error("initializeWasm() must be awaited first!");
3865 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3866 return nativeResponseValue;
3868 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3870 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3871 if(!isWasmInitialized) {
3872 throw new Error("initializeWasm() must be awaited first!");
3874 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3875 return nativeResponseValue;
3877 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3879 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3880 if(!isWasmInitialized) {
3881 throw new Error("initializeWasm() must be awaited first!");
3883 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3884 return nativeResponseValue;
3886 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3888 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
3889 if(!isWasmInitialized) {
3890 throw new Error("initializeWasm() must be awaited first!");
3892 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3893 return nativeResponseValue;
3895 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3897 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
3898 if(!isWasmInitialized) {
3899 throw new Error("initializeWasm() must be awaited first!");
3901 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3902 return nativeResponseValue;
3904 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3906 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
3907 if(!isWasmInitialized) {
3908 throw new Error("initializeWasm() must be awaited first!");
3910 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3911 return nativeResponseValue;
3913 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3915 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
3916 if(!isWasmInitialized) {
3917 throw new Error("initializeWasm() must be awaited first!");
3919 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3920 return nativeResponseValue;
3922 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3924 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
3925 if(!isWasmInitialized) {
3926 throw new Error("initializeWasm() must be awaited first!");
3928 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3929 return nativeResponseValue;
3931 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3933 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
3934 if(!isWasmInitialized) {
3935 throw new Error("initializeWasm() must be awaited first!");
3937 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3938 return nativeResponseValue;
3941 export interface LDKWatch {
3942 watch_channel (funding_txo: bigint, monitor: bigint): bigint;
3943 update_channel (funding_txo: bigint, update: bigint): bigint;
3944 release_pending_monitor_events (): number;
3948 export function LDKWatch_new(impl: LDKWatch): bigint {
3949 if(!isWasmInitialized) {
3950 throw new Error("initializeWasm() must be awaited first!");
3952 var new_obj_idx = js_objs.length;
3953 for (var i = 0; i < js_objs.length; i++) {
3954 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3956 js_objs[i] = new WeakRef(impl);
3957 return wasm.TS_LDKWatch_new(i);
3959 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3961 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): bigint {
3962 if(!isWasmInitialized) {
3963 throw new Error("initializeWasm() must be awaited first!");
3965 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3966 return nativeResponseValue;
3968 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3970 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): bigint {
3971 if(!isWasmInitialized) {
3972 throw new Error("initializeWasm() must be awaited first!");
3974 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3975 return nativeResponseValue;
3977 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3979 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
3980 if(!isWasmInitialized) {
3981 throw new Error("initializeWasm() must be awaited first!");
3983 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3984 return nativeResponseValue;
3987 export interface LDKBroadcasterInterface {
3988 broadcast_transaction (tx: number): void;
3992 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): bigint {
3993 if(!isWasmInitialized) {
3994 throw new Error("initializeWasm() must be awaited first!");
3996 var new_obj_idx = js_objs.length;
3997 for (var i = 0; i < js_objs.length; i++) {
3998 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4000 js_objs[i] = new WeakRef(impl);
4001 return wasm.TS_LDKBroadcasterInterface_new(i);
4003 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4005 export function BroadcasterInterface_broadcast_transaction(this_arg: bigint, tx: number): void {
4006 if(!isWasmInitialized) {
4007 throw new Error("initializeWasm() must be awaited first!");
4009 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4010 // debug statements here
4013 export interface LDKKeysInterface {
4014 get_node_secret (recipient: Recipient): bigint;
4015 get_destination_script (): number;
4016 get_shutdown_scriptpubkey (): bigint;
4017 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): bigint;
4018 get_secure_random_bytes (): number;
4019 read_chan_signer (reader: number): bigint;
4020 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint;
4021 get_inbound_payment_key_material (): number;
4025 export function LDKKeysInterface_new(impl: LDKKeysInterface): bigint {
4026 if(!isWasmInitialized) {
4027 throw new Error("initializeWasm() must be awaited first!");
4029 var new_obj_idx = js_objs.length;
4030 for (var i = 0; i < js_objs.length; i++) {
4031 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4033 js_objs[i] = new WeakRef(impl);
4034 return wasm.TS_LDKKeysInterface_new(i);
4036 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4038 export function KeysInterface_get_node_secret(this_arg: bigint, recipient: Recipient): bigint {
4039 if(!isWasmInitialized) {
4040 throw new Error("initializeWasm() must be awaited first!");
4042 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
4043 return nativeResponseValue;
4045 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4047 export function KeysInterface_get_destination_script(this_arg: bigint): number {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4052 return nativeResponseValue;
4054 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4056 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4057 if(!isWasmInitialized) {
4058 throw new Error("initializeWasm() must be awaited first!");
4060 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4061 return nativeResponseValue;
4063 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4065 export function KeysInterface_get_channel_signer(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint): bigint {
4066 if(!isWasmInitialized) {
4067 throw new Error("initializeWasm() must be awaited first!");
4069 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4070 return nativeResponseValue;
4072 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4074 export function KeysInterface_get_secure_random_bytes(this_arg: bigint): number {
4075 if(!isWasmInitialized) {
4076 throw new Error("initializeWasm() must be awaited first!");
4078 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4079 return nativeResponseValue;
4081 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4083 export function KeysInterface_read_chan_signer(this_arg: bigint, reader: number): bigint {
4084 if(!isWasmInitialized) {
4085 throw new Error("initializeWasm() must be awaited first!");
4087 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4088 return nativeResponseValue;
4090 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
4092 export function KeysInterface_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, receipient: Recipient): bigint {
4093 if(!isWasmInitialized) {
4094 throw new Error("initializeWasm() must be awaited first!");
4096 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
4097 return nativeResponseValue;
4099 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4101 export function KeysInterface_get_inbound_payment_key_material(this_arg: bigint): number {
4102 if(!isWasmInitialized) {
4103 throw new Error("initializeWasm() must be awaited first!");
4105 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4106 return nativeResponseValue;
4109 export interface LDKFeeEstimator {
4110 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4114 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): bigint {
4115 if(!isWasmInitialized) {
4116 throw new Error("initializeWasm() must be awaited first!");
4118 var new_obj_idx = js_objs.length;
4119 for (var i = 0; i < js_objs.length; i++) {
4120 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4122 js_objs[i] = new WeakRef(impl);
4123 return wasm.TS_LDKFeeEstimator_new(i);
4125 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4127 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4128 if(!isWasmInitialized) {
4129 throw new Error("initializeWasm() must be awaited first!");
4131 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4132 return nativeResponseValue;
4134 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4136 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: bigint): number {
4137 if(!isWasmInitialized) {
4138 throw new Error("initializeWasm() must be awaited first!");
4140 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4141 return nativeResponseValue;
4143 // struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4145 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: bigint): bigint {
4146 if(!isWasmInitialized) {
4147 throw new Error("initializeWasm() must be awaited first!");
4149 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4150 return nativeResponseValue;
4152 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4154 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
4155 if(!isWasmInitialized) {
4156 throw new Error("initializeWasm() must be awaited first!");
4158 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4159 return nativeResponseValue;
4161 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4163 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
4164 if(!isWasmInitialized) {
4165 throw new Error("initializeWasm() must be awaited first!");
4167 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4168 return nativeResponseValue;
4170 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4172 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
4173 if(!isWasmInitialized) {
4174 throw new Error("initializeWasm() must be awaited first!");
4176 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4177 return nativeResponseValue;
4179 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4181 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
4182 if(!isWasmInitialized) {
4183 throw new Error("initializeWasm() must be awaited first!");
4185 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4186 return nativeResponseValue;
4188 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4190 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
4191 if(!isWasmInitialized) {
4192 throw new Error("initializeWasm() must be awaited first!");
4194 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
4195 return nativeResponseValue;
4197 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4199 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
4200 if(!isWasmInitialized) {
4201 throw new Error("initializeWasm() must be awaited first!");
4203 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
4204 return nativeResponseValue;
4207 export interface LDKType {
4209 debug_str (): number;
4214 export function LDKType_new(impl: LDKType): bigint {
4215 if(!isWasmInitialized) {
4216 throw new Error("initializeWasm() must be awaited first!");
4218 var new_obj_idx = js_objs.length;
4219 for (var i = 0; i < js_objs.length; i++) {
4220 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4222 js_objs[i] = new WeakRef(impl);
4223 return wasm.TS_LDKType_new(i);
4225 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4227 export function Type_type_id(this_arg: bigint): number {
4228 if(!isWasmInitialized) {
4229 throw new Error("initializeWasm() must be awaited first!");
4231 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4232 return nativeResponseValue;
4234 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4236 export function Type_debug_str(this_arg: bigint): number {
4237 if(!isWasmInitialized) {
4238 throw new Error("initializeWasm() must be awaited first!");
4240 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4241 return nativeResponseValue;
4243 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4245 export function Type_write(this_arg: bigint): number {
4246 if(!isWasmInitialized) {
4247 throw new Error("initializeWasm() must be awaited first!");
4249 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4250 return nativeResponseValue;
4253 export class LDKCOption_TypeZ {
4254 protected constructor() {}
4257 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
4258 if(!isWasmInitialized) {
4259 throw new Error("initializeWasm() must be awaited first!");
4261 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4262 return nativeResponseValue;
4265 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
4266 if(!isWasmInitialized) {
4267 throw new Error("initializeWasm() must be awaited first!");
4269 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4270 return nativeResponseValue;
4272 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4274 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
4275 if(!isWasmInitialized) {
4276 throw new Error("initializeWasm() must be awaited first!");
4278 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4279 return nativeResponseValue;
4281 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4283 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
4284 if(!isWasmInitialized) {
4285 throw new Error("initializeWasm() must be awaited first!");
4287 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4288 return nativeResponseValue;
4291 export class LDKPaymentError {
4292 protected constructor() {}
4295 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
4296 if(!isWasmInitialized) {
4297 throw new Error("initializeWasm() must be awaited first!");
4299 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4300 return nativeResponseValue;
4303 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
4304 if(!isWasmInitialized) {
4305 throw new Error("initializeWasm() must be awaited first!");
4307 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4308 return nativeResponseValue;
4311 export function LDKPaymentError_Routing_get_routing(ptr: bigint): bigint {
4312 if(!isWasmInitialized) {
4313 throw new Error("initializeWasm() must be awaited first!");
4315 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4316 return nativeResponseValue;
4319 export function LDKPaymentError_Sending_get_sending(ptr: bigint): bigint {
4320 if(!isWasmInitialized) {
4321 throw new Error("initializeWasm() must be awaited first!");
4323 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4324 return nativeResponseValue;
4326 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4328 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: bigint): number {
4329 if(!isWasmInitialized) {
4330 throw new Error("initializeWasm() must be awaited first!");
4332 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4333 return nativeResponseValue;
4335 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4337 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: bigint): bigint {
4338 if(!isWasmInitialized) {
4339 throw new Error("initializeWasm() must be awaited first!");
4341 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4342 return nativeResponseValue;
4345 export class LDKParseError {
4346 protected constructor() {}
4349 export function LDKParseError_ty_from_ptr(ptr: bigint): number {
4350 if(!isWasmInitialized) {
4351 throw new Error("initializeWasm() must be awaited first!");
4353 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4354 return nativeResponseValue;
4357 export function LDKParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
4358 if(!isWasmInitialized) {
4359 throw new Error("initializeWasm() must be awaited first!");
4361 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4362 return nativeResponseValue;
4365 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
4366 if(!isWasmInitialized) {
4367 throw new Error("initializeWasm() must be awaited first!");
4369 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4370 return nativeResponseValue;
4373 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
4374 if(!isWasmInitialized) {
4375 throw new Error("initializeWasm() must be awaited first!");
4377 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4378 return nativeResponseValue;
4381 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4386 return nativeResponseValue;
4389 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
4390 if(!isWasmInitialized) {
4391 throw new Error("initializeWasm() must be awaited first!");
4393 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4394 return nativeResponseValue;
4396 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4398 export function CResult_SiPrefixParseErrorZ_get_ok(owner: bigint): SiPrefix {
4399 if(!isWasmInitialized) {
4400 throw new Error("initializeWasm() must be awaited first!");
4402 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4403 return nativeResponseValue;
4405 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4407 export function CResult_SiPrefixParseErrorZ_get_err(owner: bigint): bigint {
4408 if(!isWasmInitialized) {
4409 throw new Error("initializeWasm() must be awaited first!");
4411 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4412 return nativeResponseValue;
4415 export class LDKParseOrSemanticError {
4416 protected constructor() {}
4419 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
4420 if(!isWasmInitialized) {
4421 throw new Error("initializeWasm() must be awaited first!");
4423 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4424 return nativeResponseValue;
4427 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
4428 if(!isWasmInitialized) {
4429 throw new Error("initializeWasm() must be awaited first!");
4431 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4432 return nativeResponseValue;
4435 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): SemanticError {
4436 if(!isWasmInitialized) {
4437 throw new Error("initializeWasm() must be awaited first!");
4439 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4440 return nativeResponseValue;
4442 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4444 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
4445 if(!isWasmInitialized) {
4446 throw new Error("initializeWasm() must be awaited first!");
4448 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4449 return nativeResponseValue;
4451 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4453 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
4454 if(!isWasmInitialized) {
4455 throw new Error("initializeWasm() must be awaited first!");
4457 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4458 return nativeResponseValue;
4460 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4462 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: bigint): bigint {
4463 if(!isWasmInitialized) {
4464 throw new Error("initializeWasm() must be awaited first!");
4466 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4467 return nativeResponseValue;
4469 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4471 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: bigint): bigint {
4472 if(!isWasmInitialized) {
4473 throw new Error("initializeWasm() must be awaited first!");
4475 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4476 return nativeResponseValue;
4478 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4480 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: bigint): bigint {
4481 if(!isWasmInitialized) {
4482 throw new Error("initializeWasm() must be awaited first!");
4484 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4485 return nativeResponseValue;
4487 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4489 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: bigint): number {
4490 if(!isWasmInitialized) {
4491 throw new Error("initializeWasm() must be awaited first!");
4493 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4494 return nativeResponseValue;
4496 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4498 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: bigint): bigint {
4499 if(!isWasmInitialized) {
4500 throw new Error("initializeWasm() must be awaited first!");
4502 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4503 return nativeResponseValue;
4505 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4507 export function CResult_PayeePubKeyErrorZ_get_ok(owner: bigint): bigint {
4508 if(!isWasmInitialized) {
4509 throw new Error("initializeWasm() must be awaited first!");
4511 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4512 return nativeResponseValue;
4514 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4516 export function CResult_PayeePubKeyErrorZ_get_err(owner: bigint): Secp256k1Error {
4517 if(!isWasmInitialized) {
4518 throw new Error("initializeWasm() must be awaited first!");
4520 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4521 return nativeResponseValue;
4523 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4525 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
4526 if(!isWasmInitialized) {
4527 throw new Error("initializeWasm() must be awaited first!");
4529 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4530 return nativeResponseValue;
4532 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4534 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
4535 if(!isWasmInitialized) {
4536 throw new Error("initializeWasm() must be awaited first!");
4538 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4539 return nativeResponseValue;
4541 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4543 export function CResult_NoneSemanticErrorZ_get_ok(owner: bigint): void {
4544 if(!isWasmInitialized) {
4545 throw new Error("initializeWasm() must be awaited first!");
4547 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4548 // debug statements here
4550 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4552 export function CResult_NoneSemanticErrorZ_get_err(owner: bigint): SemanticError {
4553 if(!isWasmInitialized) {
4554 throw new Error("initializeWasm() must be awaited first!");
4556 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4557 return nativeResponseValue;
4559 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4561 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: bigint): bigint {
4562 if(!isWasmInitialized) {
4563 throw new Error("initializeWasm() must be awaited first!");
4565 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4566 return nativeResponseValue;
4568 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4570 export function CResult_InvoiceSemanticErrorZ_get_err(owner: bigint): SemanticError {
4571 if(!isWasmInitialized) {
4572 throw new Error("initializeWasm() must be awaited first!");
4574 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4575 return nativeResponseValue;
4577 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4579 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
4580 if(!isWasmInitialized) {
4581 throw new Error("initializeWasm() must be awaited first!");
4583 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4584 return nativeResponseValue;
4586 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4588 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
4589 if(!isWasmInitialized) {
4590 throw new Error("initializeWasm() must be awaited first!");
4592 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4593 return nativeResponseValue;
4595 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4597 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
4598 if(!isWasmInitialized) {
4599 throw new Error("initializeWasm() must be awaited first!");
4601 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4602 return nativeResponseValue;
4604 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4606 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
4607 if(!isWasmInitialized) {
4608 throw new Error("initializeWasm() must be awaited first!");
4610 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4611 return nativeResponseValue;
4613 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4615 export function CResult_StringErrorZ_get_ok(owner: bigint): number {
4616 if(!isWasmInitialized) {
4617 throw new Error("initializeWasm() must be awaited first!");
4619 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4620 return nativeResponseValue;
4622 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4624 export function CResult_StringErrorZ_get_err(owner: bigint): Secp256k1Error {
4625 if(!isWasmInitialized) {
4626 throw new Error("initializeWasm() must be awaited first!");
4628 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4629 return nativeResponseValue;
4631 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4633 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4634 if(!isWasmInitialized) {
4635 throw new Error("initializeWasm() must be awaited first!");
4637 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4638 return nativeResponseValue;
4640 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4642 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4643 if(!isWasmInitialized) {
4644 throw new Error("initializeWasm() must be awaited first!");
4646 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4647 return nativeResponseValue;
4650 export class LDKCOption_MonitorEventZ {
4651 protected constructor() {}
4654 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
4655 if(!isWasmInitialized) {
4656 throw new Error("initializeWasm() must be awaited first!");
4658 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4659 return nativeResponseValue;
4662 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
4663 if(!isWasmInitialized) {
4664 throw new Error("initializeWasm() must be awaited first!");
4666 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4667 return nativeResponseValue;
4669 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4671 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
4672 if(!isWasmInitialized) {
4673 throw new Error("initializeWasm() must be awaited first!");
4675 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4676 return nativeResponseValue;
4678 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4680 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
4681 if(!isWasmInitialized) {
4682 throw new Error("initializeWasm() must be awaited first!");
4684 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4685 return nativeResponseValue;
4687 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4689 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
4690 if(!isWasmInitialized) {
4691 throw new Error("initializeWasm() must be awaited first!");
4693 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4694 return nativeResponseValue;
4696 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4698 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
4699 if(!isWasmInitialized) {
4700 throw new Error("initializeWasm() must be awaited first!");
4702 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4703 return nativeResponseValue;
4705 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4707 export function C2Tuple_OutPointScriptZ_get_a(owner: bigint): bigint {
4708 if(!isWasmInitialized) {
4709 throw new Error("initializeWasm() must be awaited first!");
4711 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4712 return nativeResponseValue;
4714 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4716 export function C2Tuple_OutPointScriptZ_get_b(owner: bigint): number {
4717 if(!isWasmInitialized) {
4718 throw new Error("initializeWasm() must be awaited first!");
4720 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4721 return nativeResponseValue;
4723 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4725 export function C2Tuple_u32ScriptZ_get_a(owner: bigint): number {
4726 if(!isWasmInitialized) {
4727 throw new Error("initializeWasm() must be awaited first!");
4729 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4730 return nativeResponseValue;
4732 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4734 export function C2Tuple_u32ScriptZ_get_b(owner: bigint): number {
4735 if(!isWasmInitialized) {
4736 throw new Error("initializeWasm() must be awaited first!");
4738 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4739 return nativeResponseValue;
4741 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4743 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: bigint): number {
4744 if(!isWasmInitialized) {
4745 throw new Error("initializeWasm() must be awaited first!");
4747 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4748 return nativeResponseValue;
4750 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4752 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: bigint): number {
4753 if(!isWasmInitialized) {
4754 throw new Error("initializeWasm() must be awaited first!");
4756 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4757 return nativeResponseValue;
4759 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4761 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
4762 if(!isWasmInitialized) {
4763 throw new Error("initializeWasm() must be awaited first!");
4765 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4766 return nativeResponseValue;
4768 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4770 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
4771 if(!isWasmInitialized) {
4772 throw new Error("initializeWasm() must be awaited first!");
4774 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4775 return nativeResponseValue;
4777 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4779 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
4780 if(!isWasmInitialized) {
4781 throw new Error("initializeWasm() must be awaited first!");
4783 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4784 return nativeResponseValue;
4786 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4788 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
4789 if(!isWasmInitialized) {
4790 throw new Error("initializeWasm() must be awaited first!");
4792 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4793 return nativeResponseValue;
4796 export class LDKBalance {
4797 protected constructor() {}
4800 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
4801 if(!isWasmInitialized) {
4802 throw new Error("initializeWasm() must be awaited first!");
4804 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4805 return nativeResponseValue;
4808 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: bigint): bigint {
4809 if(!isWasmInitialized) {
4810 throw new Error("initializeWasm() must be awaited first!");
4812 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4813 return nativeResponseValue;
4816 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: bigint): bigint {
4817 if(!isWasmInitialized) {
4818 throw new Error("initializeWasm() must be awaited first!");
4820 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4821 return nativeResponseValue;
4824 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
4825 if(!isWasmInitialized) {
4826 throw new Error("initializeWasm() must be awaited first!");
4828 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4829 return nativeResponseValue;
4832 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: bigint): bigint {
4833 if(!isWasmInitialized) {
4834 throw new Error("initializeWasm() must be awaited first!");
4836 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4837 return nativeResponseValue;
4840 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
4841 if(!isWasmInitialized) {
4842 throw new Error("initializeWasm() must be awaited first!");
4844 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4845 return nativeResponseValue;
4848 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: bigint): bigint {
4849 if(!isWasmInitialized) {
4850 throw new Error("initializeWasm() must be awaited first!");
4852 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4853 return nativeResponseValue;
4856 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: bigint): number {
4857 if(!isWasmInitialized) {
4858 throw new Error("initializeWasm() must be awaited first!");
4860 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4861 return nativeResponseValue;
4863 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4865 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: bigint): number {
4866 if(!isWasmInitialized) {
4867 throw new Error("initializeWasm() must be awaited first!");
4869 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4870 return nativeResponseValue;
4872 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4874 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: bigint): bigint {
4875 if(!isWasmInitialized) {
4876 throw new Error("initializeWasm() must be awaited first!");
4878 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4879 return nativeResponseValue;
4881 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4883 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
4884 if(!isWasmInitialized) {
4885 throw new Error("initializeWasm() must be awaited first!");
4887 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4888 return nativeResponseValue;
4890 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4892 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
4893 if(!isWasmInitialized) {
4894 throw new Error("initializeWasm() must be awaited first!");
4896 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4897 return nativeResponseValue;
4899 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4901 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
4902 if(!isWasmInitialized) {
4903 throw new Error("initializeWasm() must be awaited first!");
4905 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4906 return nativeResponseValue;
4908 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4910 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
4911 if(!isWasmInitialized) {
4912 throw new Error("initializeWasm() must be awaited first!");
4914 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4915 return nativeResponseValue;
4918 export class LDKCOption_NetAddressZ {
4919 protected constructor() {}
4922 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: bigint): number {
4923 if(!isWasmInitialized) {
4924 throw new Error("initializeWasm() must be awaited first!");
4926 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4927 return nativeResponseValue;
4930 export function LDKCOption_NetAddressZ_Some_get_some(ptr: bigint): bigint {
4931 if(!isWasmInitialized) {
4932 throw new Error("initializeWasm() must be awaited first!");
4934 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4935 return nativeResponseValue;
4937 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4939 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
4940 if(!isWasmInitialized) {
4941 throw new Error("initializeWasm() must be awaited first!");
4943 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4944 return nativeResponseValue;
4946 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4948 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
4949 if(!isWasmInitialized) {
4950 throw new Error("initializeWasm() must be awaited first!");
4952 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4953 return nativeResponseValue;
4955 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4957 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
4958 if(!isWasmInitialized) {
4959 throw new Error("initializeWasm() must be awaited first!");
4961 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4962 // debug statements here
4964 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4966 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
4967 if(!isWasmInitialized) {
4968 throw new Error("initializeWasm() must be awaited first!");
4970 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4971 return nativeResponseValue;
4973 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4975 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
4976 if(!isWasmInitialized) {
4977 throw new Error("initializeWasm() must be awaited first!");
4979 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4980 return nativeResponseValue;
4982 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4984 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
4985 if(!isWasmInitialized) {
4986 throw new Error("initializeWasm() must be awaited first!");
4988 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4989 return nativeResponseValue;
4991 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4993 export function CResult_NoneErrorZ_get_ok(owner: bigint): void {
4994 if(!isWasmInitialized) {
4995 throw new Error("initializeWasm() must be awaited first!");
4997 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4998 // debug statements here
5000 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
5002 export function CResult_NoneErrorZ_get_err(owner: bigint): IOError {
5003 if(!isWasmInitialized) {
5004 throw new Error("initializeWasm() must be awaited first!");
5006 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
5007 return nativeResponseValue;
5009 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5011 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
5012 if(!isWasmInitialized) {
5013 throw new Error("initializeWasm() must be awaited first!");
5015 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
5016 return nativeResponseValue;
5018 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5020 export function CResult_NetAddressDecodeErrorZ_get_err(owner: bigint): bigint {
5021 if(!isWasmInitialized) {
5022 throw new Error("initializeWasm() must be awaited first!");
5024 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
5025 return nativeResponseValue;
5027 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5029 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5030 if(!isWasmInitialized) {
5031 throw new Error("initializeWasm() must be awaited first!");
5033 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5034 return nativeResponseValue;
5036 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5038 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5039 if(!isWasmInitialized) {
5040 throw new Error("initializeWasm() must be awaited first!");
5042 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5043 return nativeResponseValue;
5045 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5047 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
5048 if(!isWasmInitialized) {
5049 throw new Error("initializeWasm() must be awaited first!");
5051 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5052 return nativeResponseValue;
5054 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5056 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
5057 if(!isWasmInitialized) {
5058 throw new Error("initializeWasm() must be awaited first!");
5060 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
5061 return nativeResponseValue;
5063 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5065 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
5066 if(!isWasmInitialized) {
5067 throw new Error("initializeWasm() must be awaited first!");
5069 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
5070 return nativeResponseValue;
5072 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5074 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
5075 if(!isWasmInitialized) {
5076 throw new Error("initializeWasm() must be awaited first!");
5078 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
5079 return nativeResponseValue;
5081 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5083 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5084 if(!isWasmInitialized) {
5085 throw new Error("initializeWasm() must be awaited first!");
5087 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
5088 return nativeResponseValue;
5090 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5092 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5093 if(!isWasmInitialized) {
5094 throw new Error("initializeWasm() must be awaited first!");
5096 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
5097 return nativeResponseValue;
5099 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5101 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5102 if(!isWasmInitialized) {
5103 throw new Error("initializeWasm() must be awaited first!");
5105 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
5106 return nativeResponseValue;
5108 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5110 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5111 if(!isWasmInitialized) {
5112 throw new Error("initializeWasm() must be awaited first!");
5114 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
5115 return nativeResponseValue;
5117 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5119 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5120 if(!isWasmInitialized) {
5121 throw new Error("initializeWasm() must be awaited first!");
5123 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
5124 return nativeResponseValue;
5126 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5128 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5129 if(!isWasmInitialized) {
5130 throw new Error("initializeWasm() must be awaited first!");
5132 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
5133 return nativeResponseValue;
5135 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5137 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
5138 if(!isWasmInitialized) {
5139 throw new Error("initializeWasm() must be awaited first!");
5141 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
5142 return nativeResponseValue;
5144 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5146 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
5147 if(!isWasmInitialized) {
5148 throw new Error("initializeWasm() must be awaited first!");
5150 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
5151 return nativeResponseValue;
5153 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5155 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
5156 if(!isWasmInitialized) {
5157 throw new Error("initializeWasm() must be awaited first!");
5159 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
5160 return nativeResponseValue;
5162 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5164 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
5165 if(!isWasmInitialized) {
5166 throw new Error("initializeWasm() must be awaited first!");
5168 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
5169 return nativeResponseValue;
5171 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5173 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
5174 if(!isWasmInitialized) {
5175 throw new Error("initializeWasm() must be awaited first!");
5177 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
5178 return nativeResponseValue;
5180 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5182 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
5183 if(!isWasmInitialized) {
5184 throw new Error("initializeWasm() must be awaited first!");
5186 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
5187 return nativeResponseValue;
5189 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5191 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
5192 if(!isWasmInitialized) {
5193 throw new Error("initializeWasm() must be awaited first!");
5195 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
5196 return nativeResponseValue;
5198 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5200 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
5201 if(!isWasmInitialized) {
5202 throw new Error("initializeWasm() must be awaited first!");
5204 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
5205 return nativeResponseValue;
5207 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5209 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
5210 if(!isWasmInitialized) {
5211 throw new Error("initializeWasm() must be awaited first!");
5213 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5214 return nativeResponseValue;
5216 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5218 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
5219 if(!isWasmInitialized) {
5220 throw new Error("initializeWasm() must be awaited first!");
5222 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5223 return nativeResponseValue;
5225 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5227 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
5228 if(!isWasmInitialized) {
5229 throw new Error("initializeWasm() must be awaited first!");
5231 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5232 return nativeResponseValue;
5234 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5236 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
5237 if(!isWasmInitialized) {
5238 throw new Error("initializeWasm() must be awaited first!");
5240 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5241 return nativeResponseValue;
5243 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5245 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
5246 if(!isWasmInitialized) {
5247 throw new Error("initializeWasm() must be awaited first!");
5249 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5250 return nativeResponseValue;
5252 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5254 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
5255 if(!isWasmInitialized) {
5256 throw new Error("initializeWasm() must be awaited first!");
5258 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5259 return nativeResponseValue;
5261 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5263 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5264 if(!isWasmInitialized) {
5265 throw new Error("initializeWasm() must be awaited first!");
5267 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5268 return nativeResponseValue;
5270 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5272 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5273 if(!isWasmInitialized) {
5274 throw new Error("initializeWasm() must be awaited first!");
5276 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5277 return nativeResponseValue;
5279 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5281 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5282 if(!isWasmInitialized) {
5283 throw new Error("initializeWasm() must be awaited first!");
5285 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5286 return nativeResponseValue;
5288 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5290 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5291 if(!isWasmInitialized) {
5292 throw new Error("initializeWasm() must be awaited first!");
5294 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5295 return nativeResponseValue;
5297 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5299 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
5300 if(!isWasmInitialized) {
5301 throw new Error("initializeWasm() must be awaited first!");
5303 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5304 return nativeResponseValue;
5306 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5308 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
5309 if(!isWasmInitialized) {
5310 throw new Error("initializeWasm() must be awaited first!");
5312 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5313 return nativeResponseValue;
5315 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5317 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5318 if(!isWasmInitialized) {
5319 throw new Error("initializeWasm() must be awaited first!");
5321 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5322 return nativeResponseValue;
5324 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5326 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5327 if(!isWasmInitialized) {
5328 throw new Error("initializeWasm() must be awaited first!");
5330 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5331 return nativeResponseValue;
5333 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5335 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
5336 if(!isWasmInitialized) {
5337 throw new Error("initializeWasm() must be awaited first!");
5339 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5340 return nativeResponseValue;
5342 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5344 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
5345 if(!isWasmInitialized) {
5346 throw new Error("initializeWasm() must be awaited first!");
5348 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5349 return nativeResponseValue;
5351 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5353 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
5354 if(!isWasmInitialized) {
5355 throw new Error("initializeWasm() must be awaited first!");
5357 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5358 return nativeResponseValue;
5360 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5362 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
5363 if(!isWasmInitialized) {
5364 throw new Error("initializeWasm() must be awaited first!");
5366 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5367 return nativeResponseValue;
5369 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5371 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
5372 if(!isWasmInitialized) {
5373 throw new Error("initializeWasm() must be awaited first!");
5375 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5376 return nativeResponseValue;
5378 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5380 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
5381 if(!isWasmInitialized) {
5382 throw new Error("initializeWasm() must be awaited first!");
5384 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5385 return nativeResponseValue;
5387 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5389 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5390 if(!isWasmInitialized) {
5391 throw new Error("initializeWasm() must be awaited first!");
5393 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5394 return nativeResponseValue;
5396 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5398 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5399 if(!isWasmInitialized) {
5400 throw new Error("initializeWasm() must be awaited first!");
5402 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5403 return nativeResponseValue;
5405 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5407 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5408 if(!isWasmInitialized) {
5409 throw new Error("initializeWasm() must be awaited first!");
5411 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5412 return nativeResponseValue;
5414 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5416 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5417 if(!isWasmInitialized) {
5418 throw new Error("initializeWasm() must be awaited first!");
5420 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5421 return nativeResponseValue;
5423 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5425 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5426 if(!isWasmInitialized) {
5427 throw new Error("initializeWasm() must be awaited first!");
5429 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5430 return nativeResponseValue;
5432 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5434 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5435 if(!isWasmInitialized) {
5436 throw new Error("initializeWasm() must be awaited first!");
5438 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5439 return nativeResponseValue;
5441 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5443 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5444 if(!isWasmInitialized) {
5445 throw new Error("initializeWasm() must be awaited first!");
5447 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5448 return nativeResponseValue;
5450 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5452 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5453 if(!isWasmInitialized) {
5454 throw new Error("initializeWasm() must be awaited first!");
5456 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5457 return nativeResponseValue;
5459 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5461 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5462 if(!isWasmInitialized) {
5463 throw new Error("initializeWasm() must be awaited first!");
5465 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5466 return nativeResponseValue;
5468 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5470 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5471 if(!isWasmInitialized) {
5472 throw new Error("initializeWasm() must be awaited first!");
5474 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5475 return nativeResponseValue;
5477 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5479 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
5480 if(!isWasmInitialized) {
5481 throw new Error("initializeWasm() must be awaited first!");
5483 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5484 return nativeResponseValue;
5486 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5488 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
5489 if(!isWasmInitialized) {
5490 throw new Error("initializeWasm() must be awaited first!");
5492 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5493 return nativeResponseValue;
5495 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5497 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5498 if(!isWasmInitialized) {
5499 throw new Error("initializeWasm() must be awaited first!");
5501 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5502 return nativeResponseValue;
5504 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5506 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5507 if(!isWasmInitialized) {
5508 throw new Error("initializeWasm() must be awaited first!");
5510 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5511 return nativeResponseValue;
5513 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5515 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
5516 if(!isWasmInitialized) {
5517 throw new Error("initializeWasm() must be awaited first!");
5519 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5520 return nativeResponseValue;
5522 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5524 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
5525 if(!isWasmInitialized) {
5526 throw new Error("initializeWasm() must be awaited first!");
5528 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5529 return nativeResponseValue;
5531 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5533 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
5534 if(!isWasmInitialized) {
5535 throw new Error("initializeWasm() must be awaited first!");
5537 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5538 return nativeResponseValue;
5540 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5542 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
5543 if(!isWasmInitialized) {
5544 throw new Error("initializeWasm() must be awaited first!");
5546 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5547 return nativeResponseValue;
5549 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5551 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
5552 if(!isWasmInitialized) {
5553 throw new Error("initializeWasm() must be awaited first!");
5555 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5556 return nativeResponseValue;
5558 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5560 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
5561 if(!isWasmInitialized) {
5562 throw new Error("initializeWasm() must be awaited first!");
5564 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5565 return nativeResponseValue;
5567 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5569 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5570 if(!isWasmInitialized) {
5571 throw new Error("initializeWasm() must be awaited first!");
5573 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5574 return nativeResponseValue;
5576 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5578 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5579 if(!isWasmInitialized) {
5580 throw new Error("initializeWasm() must be awaited first!");
5582 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5583 return nativeResponseValue;
5585 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5587 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
5588 if(!isWasmInitialized) {
5589 throw new Error("initializeWasm() must be awaited first!");
5591 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5592 return nativeResponseValue;
5594 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5596 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
5597 if(!isWasmInitialized) {
5598 throw new Error("initializeWasm() must be awaited first!");
5600 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5601 return nativeResponseValue;
5603 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5605 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
5606 if(!isWasmInitialized) {
5607 throw new Error("initializeWasm() must be awaited first!");
5609 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5610 return nativeResponseValue;
5612 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5614 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
5615 if(!isWasmInitialized) {
5616 throw new Error("initializeWasm() must be awaited first!");
5618 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5619 return nativeResponseValue;
5622 export class LDKSignOrCreationError {
5623 protected constructor() {}
5626 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
5627 if(!isWasmInitialized) {
5628 throw new Error("initializeWasm() must be awaited first!");
5630 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5631 return nativeResponseValue;
5634 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
5635 if(!isWasmInitialized) {
5636 throw new Error("initializeWasm() must be awaited first!");
5638 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5639 return nativeResponseValue;
5641 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5643 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
5644 if(!isWasmInitialized) {
5645 throw new Error("initializeWasm() must be awaited first!");
5647 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5648 return nativeResponseValue;
5650 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5652 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
5653 if(!isWasmInitialized) {
5654 throw new Error("initializeWasm() must be awaited first!");
5656 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5657 return nativeResponseValue;
5660 export interface LDKFilter {
5661 register_tx (txid: number, script_pubkey: number): void;
5662 register_output (output: bigint): bigint;
5666 export function LDKFilter_new(impl: LDKFilter): bigint {
5667 if(!isWasmInitialized) {
5668 throw new Error("initializeWasm() must be awaited first!");
5670 var new_obj_idx = js_objs.length;
5671 for (var i = 0; i < js_objs.length; i++) {
5672 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5674 js_objs[i] = new WeakRef(impl);
5675 return wasm.TS_LDKFilter_new(i);
5677 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5679 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
5680 if(!isWasmInitialized) {
5681 throw new Error("initializeWasm() must be awaited first!");
5683 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5684 // debug statements here
5686 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5688 export function Filter_register_output(this_arg: bigint, output: bigint): bigint {
5689 if(!isWasmInitialized) {
5690 throw new Error("initializeWasm() must be awaited first!");
5692 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5693 return nativeResponseValue;
5696 export class LDKCOption_FilterZ {
5697 protected constructor() {}
5700 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
5701 if(!isWasmInitialized) {
5702 throw new Error("initializeWasm() must be awaited first!");
5704 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5705 return nativeResponseValue;
5708 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
5709 if(!isWasmInitialized) {
5710 throw new Error("initializeWasm() must be awaited first!");
5712 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5713 return nativeResponseValue;
5715 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5717 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
5718 if(!isWasmInitialized) {
5719 throw new Error("initializeWasm() must be awaited first!");
5721 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5722 return nativeResponseValue;
5724 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5726 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
5727 if(!isWasmInitialized) {
5728 throw new Error("initializeWasm() must be awaited first!");
5730 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5731 // debug statements here
5734 export interface LDKMessageSendEventsProvider {
5735 get_and_clear_pending_msg_events (): number;
5739 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): bigint {
5740 if(!isWasmInitialized) {
5741 throw new Error("initializeWasm() must be awaited first!");
5743 var new_obj_idx = js_objs.length;
5744 for (var i = 0; i < js_objs.length; i++) {
5745 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5747 js_objs[i] = new WeakRef(impl);
5748 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5750 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5752 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
5753 if(!isWasmInitialized) {
5754 throw new Error("initializeWasm() must be awaited first!");
5756 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5757 return nativeResponseValue;
5760 export interface LDKEventHandler {
5761 handle_event (event: bigint): void;
5765 export function LDKEventHandler_new(impl: LDKEventHandler): bigint {
5766 if(!isWasmInitialized) {
5767 throw new Error("initializeWasm() must be awaited first!");
5769 var new_obj_idx = js_objs.length;
5770 for (var i = 0; i < js_objs.length; i++) {
5771 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5773 js_objs[i] = new WeakRef(impl);
5774 return wasm.TS_LDKEventHandler_new(i);
5776 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5778 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
5779 if(!isWasmInitialized) {
5780 throw new Error("initializeWasm() must be awaited first!");
5782 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5783 // debug statements here
5786 export interface LDKEventsProvider {
5787 process_pending_events (handler: bigint): void;
5791 export function LDKEventsProvider_new(impl: LDKEventsProvider): bigint {
5792 if(!isWasmInitialized) {
5793 throw new Error("initializeWasm() must be awaited first!");
5795 var new_obj_idx = js_objs.length;
5796 for (var i = 0; i < js_objs.length; i++) {
5797 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5799 js_objs[i] = new WeakRef(impl);
5800 return wasm.TS_LDKEventsProvider_new(i);
5802 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5804 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
5805 if(!isWasmInitialized) {
5806 throw new Error("initializeWasm() must be awaited first!");
5808 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5809 // debug statements here
5812 export interface LDKScore {
5813 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint;
5814 payment_path_failed (path: number, short_channel_id: bigint): void;
5815 payment_path_successful (path: number): void;
5816 probe_failed (path: number, short_channel_id: bigint): void;
5817 probe_successful (path: number): void;
5822 export function LDKScore_new(impl: LDKScore): bigint {
5823 if(!isWasmInitialized) {
5824 throw new Error("initializeWasm() must be awaited first!");
5826 var new_obj_idx = js_objs.length;
5827 for (var i = 0; i < js_objs.length; i++) {
5828 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5830 js_objs[i] = new WeakRef(impl);
5831 return wasm.TS_LDKScore_new(i);
5833 // uint64_t Score_channel_penalty_msat LDKScore *NONNULL_PTR this_arg, uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage
5835 export function Score_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint): bigint {
5836 if(!isWasmInitialized) {
5837 throw new Error("initializeWasm() must be awaited first!");
5839 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5840 return nativeResponseValue;
5842 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5844 export function Score_payment_path_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
5845 if(!isWasmInitialized) {
5846 throw new Error("initializeWasm() must be awaited first!");
5848 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5849 // debug statements here
5851 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5853 export function Score_payment_path_successful(this_arg: bigint, path: number): void {
5854 if(!isWasmInitialized) {
5855 throw new Error("initializeWasm() must be awaited first!");
5857 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5858 // debug statements here
5860 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5862 export function Score_probe_failed(this_arg: bigint, path: number, short_channel_id: bigint): void {
5863 if(!isWasmInitialized) {
5864 throw new Error("initializeWasm() must be awaited first!");
5866 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
5867 // debug statements here
5869 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5871 export function Score_probe_successful(this_arg: bigint, path: number): void {
5872 if(!isWasmInitialized) {
5873 throw new Error("initializeWasm() must be awaited first!");
5875 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
5876 // debug statements here
5878 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5880 export function Score_write(this_arg: bigint): number {
5881 if(!isWasmInitialized) {
5882 throw new Error("initializeWasm() must be awaited first!");
5884 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5885 return nativeResponseValue;
5888 export interface LDKPersister {
5889 persist_manager (channel_manager: bigint): bigint;
5890 persist_graph (network_graph: bigint): bigint;
5891 persist_scorer (scorer: bigint): bigint;
5895 export function LDKPersister_new(impl: LDKPersister): bigint {
5896 if(!isWasmInitialized) {
5897 throw new Error("initializeWasm() must be awaited first!");
5899 var new_obj_idx = js_objs.length;
5900 for (var i = 0; i < js_objs.length; i++) {
5901 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5903 js_objs[i] = new WeakRef(impl);
5904 return wasm.TS_LDKPersister_new(i);
5906 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5908 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
5909 if(!isWasmInitialized) {
5910 throw new Error("initializeWasm() must be awaited first!");
5912 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5913 return nativeResponseValue;
5915 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5917 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
5918 if(!isWasmInitialized) {
5919 throw new Error("initializeWasm() must be awaited first!");
5921 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5922 return nativeResponseValue;
5924 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5926 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
5927 if(!isWasmInitialized) {
5928 throw new Error("initializeWasm() must be awaited first!");
5930 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5931 return nativeResponseValue;
5934 export interface LDKListen {
5935 filtered_block_connected (header: number, txdata: number, height: number): void;
5936 block_connected (block: number, height: number): void;
5937 block_disconnected (header: number, height: number): void;
5941 export function LDKListen_new(impl: LDKListen): bigint {
5942 if(!isWasmInitialized) {
5943 throw new Error("initializeWasm() must be awaited first!");
5945 var new_obj_idx = js_objs.length;
5946 for (var i = 0; i < js_objs.length; i++) {
5947 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5949 js_objs[i] = new WeakRef(impl);
5950 return wasm.TS_LDKListen_new(i);
5952 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5954 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5959 // debug statements here
5961 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5963 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5968 // debug statements here
5970 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5972 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5977 // debug statements here
5980 export interface LDKConfirm {
5981 transactions_confirmed (header: number, txdata: number, height: number): void;
5982 transaction_unconfirmed (txid: number): void;
5983 best_block_updated (header: number, height: number): void;
5984 get_relevant_txids (): number;
5988 export function LDKConfirm_new(impl: LDKConfirm): bigint {
5989 if(!isWasmInitialized) {
5990 throw new Error("initializeWasm() must be awaited first!");
5992 var new_obj_idx = js_objs.length;
5993 for (var i = 0; i < js_objs.length; i++) {
5994 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5996 js_objs[i] = new WeakRef(impl);
5997 return wasm.TS_LDKConfirm_new(i);
5999 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
6001 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
6002 if(!isWasmInitialized) {
6003 throw new Error("initializeWasm() must be awaited first!");
6005 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
6006 // debug statements here
6008 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
6010 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
6011 if(!isWasmInitialized) {
6012 throw new Error("initializeWasm() must be awaited first!");
6014 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
6015 // debug statements here
6017 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6019 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
6020 if(!isWasmInitialized) {
6021 throw new Error("initializeWasm() must be awaited first!");
6023 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
6024 // debug statements here
6026 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
6028 export function Confirm_get_relevant_txids(this_arg: bigint): number {
6029 if(!isWasmInitialized) {
6030 throw new Error("initializeWasm() must be awaited first!");
6032 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
6033 return nativeResponseValue;
6036 export interface LDKPersist {
6037 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): bigint;
6038 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): bigint;
6042 export function LDKPersist_new(impl: LDKPersist): bigint {
6043 if(!isWasmInitialized) {
6044 throw new Error("initializeWasm() must be awaited first!");
6046 var new_obj_idx = js_objs.length;
6047 for (var i = 0; i < js_objs.length; i++) {
6048 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6050 js_objs[i] = new WeakRef(impl);
6051 return wasm.TS_LDKPersist_new(i);
6053 // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
6055 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): bigint {
6056 if(!isWasmInitialized) {
6057 throw new Error("initializeWasm() must be awaited first!");
6059 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
6060 return nativeResponseValue;
6062 // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
6064 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): bigint {
6065 if(!isWasmInitialized) {
6066 throw new Error("initializeWasm() must be awaited first!");
6068 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
6069 return nativeResponseValue;
6072 export interface LDKChannelMessageHandler {
6073 handle_open_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6074 handle_accept_channel (their_node_id: number, their_features: bigint, msg: bigint): void;
6075 handle_funding_created (their_node_id: number, msg: bigint): void;
6076 handle_funding_signed (their_node_id: number, msg: bigint): void;
6077 handle_channel_ready (their_node_id: number, msg: bigint): void;
6078 handle_shutdown (their_node_id: number, their_features: bigint, msg: bigint): void;
6079 handle_closing_signed (their_node_id: number, msg: bigint): void;
6080 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
6081 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
6082 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
6083 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
6084 handle_commitment_signed (their_node_id: number, msg: bigint): void;
6085 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
6086 handle_update_fee (their_node_id: number, msg: bigint): void;
6087 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
6088 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6089 peer_connected (their_node_id: number, msg: bigint): void;
6090 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
6091 handle_channel_update (their_node_id: number, msg: bigint): void;
6092 handle_error (their_node_id: number, msg: bigint): void;
6096 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): bigint {
6097 if(!isWasmInitialized) {
6098 throw new Error("initializeWasm() must be awaited first!");
6100 var new_obj_idx = js_objs.length;
6101 for (var i = 0; i < js_objs.length; i++) {
6102 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6104 js_objs[i] = new WeakRef(impl);
6105 return wasm.TS_LDKChannelMessageHandler_new(i);
6107 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg
6109 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6110 if(!isWasmInitialized) {
6111 throw new Error("initializeWasm() must be awaited first!");
6113 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
6114 // debug statements here
6116 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg
6118 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6119 if(!isWasmInitialized) {
6120 throw new Error("initializeWasm() must be awaited first!");
6122 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
6123 // debug statements here
6125 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
6127 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
6128 if(!isWasmInitialized) {
6129 throw new Error("initializeWasm() must be awaited first!");
6131 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
6132 // debug statements here
6134 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
6136 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6137 if(!isWasmInitialized) {
6138 throw new Error("initializeWasm() must be awaited first!");
6140 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
6141 // debug statements here
6143 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
6145 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
6146 if(!isWasmInitialized) {
6147 throw new Error("initializeWasm() must be awaited first!");
6149 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
6150 // debug statements here
6152 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg
6154 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, their_features: bigint, msg: bigint): void {
6155 if(!isWasmInitialized) {
6156 throw new Error("initializeWasm() must be awaited first!");
6158 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
6159 // debug statements here
6161 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
6163 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6164 if(!isWasmInitialized) {
6165 throw new Error("initializeWasm() must be awaited first!");
6167 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
6168 // debug statements here
6170 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
6172 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6173 if(!isWasmInitialized) {
6174 throw new Error("initializeWasm() must be awaited first!");
6176 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
6177 // debug statements here
6179 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
6181 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6182 if(!isWasmInitialized) {
6183 throw new Error("initializeWasm() must be awaited first!");
6185 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
6186 // debug statements here
6188 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
6190 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6191 if(!isWasmInitialized) {
6192 throw new Error("initializeWasm() must be awaited first!");
6194 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
6195 // debug statements here
6197 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
6199 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
6200 if(!isWasmInitialized) {
6201 throw new Error("initializeWasm() must be awaited first!");
6203 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
6204 // debug statements here
6206 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
6208 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
6209 if(!isWasmInitialized) {
6210 throw new Error("initializeWasm() must be awaited first!");
6212 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
6213 // debug statements here
6215 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
6217 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
6218 if(!isWasmInitialized) {
6219 throw new Error("initializeWasm() must be awaited first!");
6221 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
6222 // debug statements here
6224 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
6226 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
6227 if(!isWasmInitialized) {
6228 throw new Error("initializeWasm() must be awaited first!");
6230 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
6231 // debug statements here
6233 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
6235 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
6236 if(!isWasmInitialized) {
6237 throw new Error("initializeWasm() must be awaited first!");
6239 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
6240 // debug statements here
6242 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6244 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number, no_connection_possible: boolean): void {
6245 if(!isWasmInitialized) {
6246 throw new Error("initializeWasm() must be awaited first!");
6248 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6249 // debug statements here
6251 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
6253 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint): void {
6254 if(!isWasmInitialized) {
6255 throw new Error("initializeWasm() must be awaited first!");
6257 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6258 // debug statements here
6260 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6262 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
6263 if(!isWasmInitialized) {
6264 throw new Error("initializeWasm() must be awaited first!");
6266 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6267 // debug statements here
6269 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6271 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
6272 if(!isWasmInitialized) {
6273 throw new Error("initializeWasm() must be awaited first!");
6275 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6276 // debug statements here
6278 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6280 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
6281 if(!isWasmInitialized) {
6282 throw new Error("initializeWasm() must be awaited first!");
6284 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6285 // debug statements here
6288 export interface LDKRoutingMessageHandler {
6289 handle_node_announcement (msg: bigint): bigint;
6290 handle_channel_announcement (msg: bigint): bigint;
6291 handle_channel_update (msg: bigint): bigint;
6292 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
6293 get_next_node_announcements (starting_point: number, batch_amount: number): number;
6294 peer_connected (their_node_id: number, init: bigint): void;
6295 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
6296 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
6297 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
6298 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
6302 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): bigint {
6303 if(!isWasmInitialized) {
6304 throw new Error("initializeWasm() must be awaited first!");
6306 var new_obj_idx = js_objs.length;
6307 for (var i = 0; i < js_objs.length; i++) {
6308 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6310 js_objs[i] = new WeakRef(impl);
6311 return wasm.TS_LDKRoutingMessageHandler_new(i);
6313 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6315 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
6316 if(!isWasmInitialized) {
6317 throw new Error("initializeWasm() must be awaited first!");
6319 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6320 return nativeResponseValue;
6322 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6324 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
6325 if(!isWasmInitialized) {
6326 throw new Error("initializeWasm() must be awaited first!");
6328 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6329 return nativeResponseValue;
6331 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6333 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
6334 if(!isWasmInitialized) {
6335 throw new Error("initializeWasm() must be awaited first!");
6337 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6338 return nativeResponseValue;
6340 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6342 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: bigint, starting_point: bigint, batch_amount: number): number {
6343 if(!isWasmInitialized) {
6344 throw new Error("initializeWasm() must be awaited first!");
6346 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6347 return nativeResponseValue;
6349 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6351 export function RoutingMessageHandler_get_next_node_announcements(this_arg: bigint, starting_point: number, batch_amount: number): number {
6352 if(!isWasmInitialized) {
6353 throw new Error("initializeWasm() must be awaited first!");
6355 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6356 return nativeResponseValue;
6358 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6360 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint): void {
6361 if(!isWasmInitialized) {
6362 throw new Error("initializeWasm() must be awaited first!");
6364 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6365 // debug statements here
6367 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6369 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6370 if(!isWasmInitialized) {
6371 throw new Error("initializeWasm() must be awaited first!");
6373 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6374 return nativeResponseValue;
6376 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6378 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6379 if(!isWasmInitialized) {
6380 throw new Error("initializeWasm() must be awaited first!");
6382 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6383 return nativeResponseValue;
6385 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6387 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6388 if(!isWasmInitialized) {
6389 throw new Error("initializeWasm() must be awaited first!");
6391 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6392 return nativeResponseValue;
6394 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6396 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
6397 if(!isWasmInitialized) {
6398 throw new Error("initializeWasm() must be awaited first!");
6400 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6401 return nativeResponseValue;
6404 export interface LDKCustomMessageReader {
6405 read (message_type: number, buffer: number): bigint;
6409 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): bigint {
6410 if(!isWasmInitialized) {
6411 throw new Error("initializeWasm() must be awaited first!");
6413 var new_obj_idx = js_objs.length;
6414 for (var i = 0; i < js_objs.length; i++) {
6415 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6417 js_objs[i] = new WeakRef(impl);
6418 return wasm.TS_LDKCustomMessageReader_new(i);
6420 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6422 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
6423 if(!isWasmInitialized) {
6424 throw new Error("initializeWasm() must be awaited first!");
6426 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6427 return nativeResponseValue;
6430 export interface LDKCustomMessageHandler {
6431 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
6432 get_and_clear_pending_msg (): number;
6436 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): bigint {
6437 if(!isWasmInitialized) {
6438 throw new Error("initializeWasm() must be awaited first!");
6440 var new_obj_idx = js_objs.length;
6441 for (var i = 0; i < js_objs.length; i++) {
6442 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6444 js_objs[i] = new WeakRef(impl);
6445 return wasm.TS_LDKCustomMessageHandler_new(i);
6447 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6449 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
6450 if(!isWasmInitialized) {
6451 throw new Error("initializeWasm() must be awaited first!");
6453 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6454 return nativeResponseValue;
6456 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6458 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
6459 if(!isWasmInitialized) {
6460 throw new Error("initializeWasm() must be awaited first!");
6462 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6463 return nativeResponseValue;
6466 export interface LDKSocketDescriptor {
6467 send_data (data: number, resume_read: boolean): number;
6468 disconnect_socket (): void;
6469 eq (other_arg: bigint): boolean;
6474 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): bigint {
6475 if(!isWasmInitialized) {
6476 throw new Error("initializeWasm() must be awaited first!");
6478 var new_obj_idx = js_objs.length;
6479 for (var i = 0; i < js_objs.length; i++) {
6480 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6482 js_objs[i] = new WeakRef(impl);
6483 return wasm.TS_LDKSocketDescriptor_new(i);
6485 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6487 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
6488 if(!isWasmInitialized) {
6489 throw new Error("initializeWasm() must be awaited first!");
6491 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6492 return nativeResponseValue;
6494 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6496 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
6497 if(!isWasmInitialized) {
6498 throw new Error("initializeWasm() must be awaited first!");
6500 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6501 // debug statements here
6503 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6505 export function SocketDescriptor_hash(this_arg: bigint): bigint {
6506 if(!isWasmInitialized) {
6507 throw new Error("initializeWasm() must be awaited first!");
6509 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6510 return nativeResponseValue;
6513 export class LDKEffectiveCapacity {
6514 protected constructor() {}
6517 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
6518 if(!isWasmInitialized) {
6519 throw new Error("initializeWasm() must be awaited first!");
6521 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6522 return nativeResponseValue;
6525 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
6526 if(!isWasmInitialized) {
6527 throw new Error("initializeWasm() must be awaited first!");
6529 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6530 return nativeResponseValue;
6533 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: bigint): bigint {
6534 if(!isWasmInitialized) {
6535 throw new Error("initializeWasm() must be awaited first!");
6537 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6538 return nativeResponseValue;
6541 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
6542 if(!isWasmInitialized) {
6543 throw new Error("initializeWasm() must be awaited first!");
6545 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6546 return nativeResponseValue;
6549 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
6550 if(!isWasmInitialized) {
6551 throw new Error("initializeWasm() must be awaited first!");
6553 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
6554 return nativeResponseValue;
6557 export interface LDKLockableScore {
6562 export function LDKLockableScore_new(impl: LDKLockableScore): bigint {
6563 if(!isWasmInitialized) {
6564 throw new Error("initializeWasm() must be awaited first!");
6566 var new_obj_idx = js_objs.length;
6567 for (var i = 0; i < js_objs.length; i++) {
6568 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6570 js_objs[i] = new WeakRef(impl);
6571 return wasm.TS_LDKLockableScore_new(i);
6573 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6575 export function LockableScore_lock(this_arg: bigint): bigint {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6580 return nativeResponseValue;
6583 export class LDKFallback {
6584 protected constructor() {}
6587 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
6588 if(!isWasmInitialized) {
6589 throw new Error("initializeWasm() must be awaited first!");
6591 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6592 return nativeResponseValue;
6595 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
6596 if(!isWasmInitialized) {
6597 throw new Error("initializeWasm() must be awaited first!");
6599 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6600 return nativeResponseValue;
6603 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
6604 if(!isWasmInitialized) {
6605 throw new Error("initializeWasm() must be awaited first!");
6607 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6608 return nativeResponseValue;
6611 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6616 return nativeResponseValue;
6619 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
6620 if(!isWasmInitialized) {
6621 throw new Error("initializeWasm() must be awaited first!");
6623 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6624 return nativeResponseValue;
6627 export interface LDKPayer {
6629 first_hops (): number;
6630 send_payment (route: bigint, payment_hash: number, payment_secret: number): bigint;
6631 send_spontaneous_payment (route: bigint, payment_preimage: number): bigint;
6632 retry_payment (route: bigint, payment_id: number): bigint;
6633 abandon_payment (payment_id: number): void;
6637 export function LDKPayer_new(impl: LDKPayer): bigint {
6638 if(!isWasmInitialized) {
6639 throw new Error("initializeWasm() must be awaited first!");
6641 var new_obj_idx = js_objs.length;
6642 for (var i = 0; i < js_objs.length; i++) {
6643 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6645 js_objs[i] = new WeakRef(impl);
6646 return wasm.TS_LDKPayer_new(i);
6648 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6650 export function Payer_node_id(this_arg: bigint): number {
6651 if(!isWasmInitialized) {
6652 throw new Error("initializeWasm() must be awaited first!");
6654 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6655 return nativeResponseValue;
6657 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6659 export function Payer_first_hops(this_arg: bigint): number {
6660 if(!isWasmInitialized) {
6661 throw new Error("initializeWasm() must be awaited first!");
6663 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6664 return nativeResponseValue;
6666 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6668 export function Payer_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number): bigint {
6669 if(!isWasmInitialized) {
6670 throw new Error("initializeWasm() must be awaited first!");
6672 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6673 return nativeResponseValue;
6675 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6677 export function Payer_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number): bigint {
6678 if(!isWasmInitialized) {
6679 throw new Error("initializeWasm() must be awaited first!");
6681 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6682 return nativeResponseValue;
6684 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6686 export function Payer_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
6687 if(!isWasmInitialized) {
6688 throw new Error("initializeWasm() must be awaited first!");
6690 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6691 return nativeResponseValue;
6693 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6695 export function Payer_abandon_payment(this_arg: bigint, payment_id: number): void {
6696 if(!isWasmInitialized) {
6697 throw new Error("initializeWasm() must be awaited first!");
6699 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6700 // debug statements here
6703 export interface LDKRouter {
6704 find_route (payer: number, route_params: bigint, payment_hash: number, first_hops: number, scorer: bigint): bigint;
6708 export function LDKRouter_new(impl: LDKRouter): bigint {
6709 if(!isWasmInitialized) {
6710 throw new Error("initializeWasm() must be awaited first!");
6712 var new_obj_idx = js_objs.length;
6713 for (var i = 0; i < js_objs.length; i++) {
6714 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6716 js_objs[i] = new WeakRef(impl);
6717 return wasm.TS_LDKRouter_new(i);
6719 // LDKCResult_RouteLightningErrorZ Router_find_route LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer
6721 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, payment_hash: number, first_hops: number, scorer: bigint): bigint {
6722 if(!isWasmInitialized) {
6723 throw new Error("initializeWasm() must be awaited first!");
6725 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6726 return nativeResponseValue;
6729 export class LDKRetry {
6730 protected constructor() {}
6733 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
6734 if(!isWasmInitialized) {
6735 throw new Error("initializeWasm() must be awaited first!");
6737 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6738 return nativeResponseValue;
6741 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
6742 if(!isWasmInitialized) {
6743 throw new Error("initializeWasm() must be awaited first!");
6745 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6746 return nativeResponseValue;
6748 // struct LDKStr _ldk_get_compiled_version(void);
6750 export function _ldk_get_compiled_version(): number {
6751 if(!isWasmInitialized) {
6752 throw new Error("initializeWasm() must be awaited first!");
6754 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6755 return nativeResponseValue;
6757 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6759 export function _ldk_c_bindings_get_compiled_version(): number {
6760 if(!isWasmInitialized) {
6761 throw new Error("initializeWasm() must be awaited first!");
6763 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6764 return nativeResponseValue;
6766 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6768 export function Bech32Error_clone_ptr(arg: bigint): bigint {
6769 if(!isWasmInitialized) {
6770 throw new Error("initializeWasm() must be awaited first!");
6772 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6773 return nativeResponseValue;
6775 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6777 export function Bech32Error_clone(orig: bigint): bigint {
6778 if(!isWasmInitialized) {
6779 throw new Error("initializeWasm() must be awaited first!");
6781 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6782 return nativeResponseValue;
6784 // void Bech32Error_free(struct LDKBech32Error o);
6786 export function Bech32Error_free(o: bigint): void {
6787 if(!isWasmInitialized) {
6788 throw new Error("initializeWasm() must be awaited first!");
6790 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6791 // debug statements here
6793 // void Transaction_free(struct LDKTransaction _res);
6795 export function Transaction_free(_res: number): void {
6796 if(!isWasmInitialized) {
6797 throw new Error("initializeWasm() must be awaited first!");
6799 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6800 // debug statements here
6802 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6804 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
6805 if(!isWasmInitialized) {
6806 throw new Error("initializeWasm() must be awaited first!");
6808 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6809 return nativeResponseValue;
6811 // void TxOut_free(struct LDKTxOut _res);
6813 export function TxOut_free(_res: bigint): void {
6814 if(!isWasmInitialized) {
6815 throw new Error("initializeWasm() must be awaited first!");
6817 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6818 // debug statements here
6820 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6822 export function TxOut_clone_ptr(arg: bigint): bigint {
6823 if(!isWasmInitialized) {
6824 throw new Error("initializeWasm() must be awaited first!");
6826 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6827 return nativeResponseValue;
6829 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6831 export function TxOut_clone(orig: bigint): bigint {
6832 if(!isWasmInitialized) {
6833 throw new Error("initializeWasm() must be awaited first!");
6835 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6836 return nativeResponseValue;
6838 // void Str_free(struct LDKStr _res);
6840 export function Str_free(_res: number): void {
6841 if(!isWasmInitialized) {
6842 throw new Error("initializeWasm() must be awaited first!");
6844 const nativeResponseValue = wasm.TS_Str_free(_res);
6845 // debug statements here
6847 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6849 export function CResult_NoneNoneZ_ok(): bigint {
6850 if(!isWasmInitialized) {
6851 throw new Error("initializeWasm() must be awaited first!");
6853 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6854 return nativeResponseValue;
6856 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6858 export function CResult_NoneNoneZ_err(): bigint {
6859 if(!isWasmInitialized) {
6860 throw new Error("initializeWasm() must be awaited first!");
6862 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6863 return nativeResponseValue;
6865 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6867 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
6868 if(!isWasmInitialized) {
6869 throw new Error("initializeWasm() must be awaited first!");
6871 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6872 return nativeResponseValue;
6874 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6876 export function CResult_NoneNoneZ_free(_res: bigint): void {
6877 if(!isWasmInitialized) {
6878 throw new Error("initializeWasm() must be awaited first!");
6880 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6881 // debug statements here
6883 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6885 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
6886 if(!isWasmInitialized) {
6887 throw new Error("initializeWasm() must be awaited first!");
6889 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6890 return nativeResponseValue;
6892 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6894 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
6895 if(!isWasmInitialized) {
6896 throw new Error("initializeWasm() must be awaited first!");
6898 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6899 return nativeResponseValue;
6901 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6903 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
6904 if(!isWasmInitialized) {
6905 throw new Error("initializeWasm() must be awaited first!");
6907 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6908 return nativeResponseValue;
6910 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6912 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
6913 if(!isWasmInitialized) {
6914 throw new Error("initializeWasm() must be awaited first!");
6916 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6917 return nativeResponseValue;
6919 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6921 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
6922 if(!isWasmInitialized) {
6923 throw new Error("initializeWasm() must be awaited first!");
6925 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6926 return nativeResponseValue;
6928 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6930 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
6931 if(!isWasmInitialized) {
6932 throw new Error("initializeWasm() must be awaited first!");
6934 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6935 // debug statements here
6937 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6939 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
6940 if(!isWasmInitialized) {
6941 throw new Error("initializeWasm() must be awaited first!");
6943 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6944 return nativeResponseValue;
6946 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6948 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
6949 if(!isWasmInitialized) {
6950 throw new Error("initializeWasm() must be awaited first!");
6952 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6953 return nativeResponseValue;
6955 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6957 export function CResult_SecretKeyErrorZ_ok(o: number): bigint {
6958 if(!isWasmInitialized) {
6959 throw new Error("initializeWasm() must be awaited first!");
6961 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6962 return nativeResponseValue;
6964 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6966 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): bigint {
6967 if(!isWasmInitialized) {
6968 throw new Error("initializeWasm() must be awaited first!");
6970 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6971 return nativeResponseValue;
6973 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6975 export function CResult_SecretKeyErrorZ_is_ok(o: bigint): boolean {
6976 if(!isWasmInitialized) {
6977 throw new Error("initializeWasm() must be awaited first!");
6979 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6980 return nativeResponseValue;
6982 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6984 export function CResult_SecretKeyErrorZ_free(_res: bigint): void {
6985 if(!isWasmInitialized) {
6986 throw new Error("initializeWasm() must be awaited first!");
6988 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6989 // debug statements here
6991 // uint64_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6993 export function CResult_SecretKeyErrorZ_clone_ptr(arg: bigint): bigint {
6994 if(!isWasmInitialized) {
6995 throw new Error("initializeWasm() must be awaited first!");
6997 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6998 return nativeResponseValue;
7000 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
7002 export function CResult_SecretKeyErrorZ_clone(orig: bigint): bigint {
7003 if(!isWasmInitialized) {
7004 throw new Error("initializeWasm() must be awaited first!");
7006 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
7007 return nativeResponseValue;
7009 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
7011 export function CResult_PublicKeyErrorZ_ok(o: number): bigint {
7012 if(!isWasmInitialized) {
7013 throw new Error("initializeWasm() must be awaited first!");
7015 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
7016 return nativeResponseValue;
7018 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
7020 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): bigint {
7021 if(!isWasmInitialized) {
7022 throw new Error("initializeWasm() must be awaited first!");
7024 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
7025 return nativeResponseValue;
7027 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
7029 export function CResult_PublicKeyErrorZ_is_ok(o: bigint): boolean {
7030 if(!isWasmInitialized) {
7031 throw new Error("initializeWasm() must be awaited first!");
7033 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
7034 return nativeResponseValue;
7036 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
7038 export function CResult_PublicKeyErrorZ_free(_res: bigint): void {
7039 if(!isWasmInitialized) {
7040 throw new Error("initializeWasm() must be awaited first!");
7042 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
7043 // debug statements here
7045 // uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
7047 export function CResult_PublicKeyErrorZ_clone_ptr(arg: bigint): bigint {
7048 if(!isWasmInitialized) {
7049 throw new Error("initializeWasm() must be awaited first!");
7051 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
7052 return nativeResponseValue;
7054 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
7056 export function CResult_PublicKeyErrorZ_clone(orig: bigint): bigint {
7057 if(!isWasmInitialized) {
7058 throw new Error("initializeWasm() must be awaited first!");
7060 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
7061 return nativeResponseValue;
7063 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
7065 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
7066 if(!isWasmInitialized) {
7067 throw new Error("initializeWasm() must be awaited first!");
7069 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
7070 return nativeResponseValue;
7072 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
7074 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
7075 if(!isWasmInitialized) {
7076 throw new Error("initializeWasm() must be awaited first!");
7078 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
7079 return nativeResponseValue;
7081 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
7083 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
7084 if(!isWasmInitialized) {
7085 throw new Error("initializeWasm() must be awaited first!");
7087 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
7088 return nativeResponseValue;
7090 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
7092 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
7093 if(!isWasmInitialized) {
7094 throw new Error("initializeWasm() must be awaited first!");
7096 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
7097 // debug statements here
7099 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
7101 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7102 if(!isWasmInitialized) {
7103 throw new Error("initializeWasm() must be awaited first!");
7105 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
7106 return nativeResponseValue;
7108 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
7110 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
7111 if(!isWasmInitialized) {
7112 throw new Error("initializeWasm() must be awaited first!");
7114 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
7115 return nativeResponseValue;
7117 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
7119 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
7120 if(!isWasmInitialized) {
7121 throw new Error("initializeWasm() must be awaited first!");
7123 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
7124 return nativeResponseValue;
7126 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
7128 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
7129 if(!isWasmInitialized) {
7130 throw new Error("initializeWasm() must be awaited first!");
7132 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
7133 return nativeResponseValue;
7135 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
7137 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
7138 if(!isWasmInitialized) {
7139 throw new Error("initializeWasm() must be awaited first!");
7141 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
7142 return nativeResponseValue;
7144 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
7146 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
7147 if(!isWasmInitialized) {
7148 throw new Error("initializeWasm() must be awaited first!");
7150 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
7151 // debug statements here
7153 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
7155 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7156 if(!isWasmInitialized) {
7157 throw new Error("initializeWasm() must be awaited first!");
7159 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
7160 return nativeResponseValue;
7162 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
7164 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
7165 if(!isWasmInitialized) {
7166 throw new Error("initializeWasm() must be awaited first!");
7168 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
7169 return nativeResponseValue;
7171 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
7173 export function CResult_TxCreationKeysErrorZ_ok(o: bigint): bigint {
7174 if(!isWasmInitialized) {
7175 throw new Error("initializeWasm() must be awaited first!");
7177 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
7178 return nativeResponseValue;
7180 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
7182 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): bigint {
7183 if(!isWasmInitialized) {
7184 throw new Error("initializeWasm() must be awaited first!");
7186 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
7187 return nativeResponseValue;
7189 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
7191 export function CResult_TxCreationKeysErrorZ_is_ok(o: bigint): boolean {
7192 if(!isWasmInitialized) {
7193 throw new Error("initializeWasm() must be awaited first!");
7195 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
7196 return nativeResponseValue;
7198 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
7200 export function CResult_TxCreationKeysErrorZ_free(_res: bigint): void {
7201 if(!isWasmInitialized) {
7202 throw new Error("initializeWasm() must be awaited first!");
7204 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
7205 // debug statements here
7207 // uint64_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
7209 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: bigint): bigint {
7210 if(!isWasmInitialized) {
7211 throw new Error("initializeWasm() must be awaited first!");
7213 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
7214 return nativeResponseValue;
7216 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
7218 export function CResult_TxCreationKeysErrorZ_clone(orig: bigint): bigint {
7219 if(!isWasmInitialized) {
7220 throw new Error("initializeWasm() must be awaited first!");
7222 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
7223 return nativeResponseValue;
7225 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
7227 export function COption_u32Z_some(o: number): bigint {
7228 if(!isWasmInitialized) {
7229 throw new Error("initializeWasm() must be awaited first!");
7231 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
7232 return nativeResponseValue;
7234 // struct LDKCOption_u32Z COption_u32Z_none(void);
7236 export function COption_u32Z_none(): bigint {
7237 if(!isWasmInitialized) {
7238 throw new Error("initializeWasm() must be awaited first!");
7240 const nativeResponseValue = wasm.TS_COption_u32Z_none();
7241 return nativeResponseValue;
7243 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
7245 export function COption_u32Z_free(_res: bigint): void {
7246 if(!isWasmInitialized) {
7247 throw new Error("initializeWasm() must be awaited first!");
7249 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
7250 // debug statements here
7252 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
7254 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
7255 if(!isWasmInitialized) {
7256 throw new Error("initializeWasm() must be awaited first!");
7258 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
7259 return nativeResponseValue;
7261 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
7263 export function COption_u32Z_clone(orig: bigint): bigint {
7264 if(!isWasmInitialized) {
7265 throw new Error("initializeWasm() must be awaited first!");
7267 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
7268 return nativeResponseValue;
7270 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
7272 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
7273 if(!isWasmInitialized) {
7274 throw new Error("initializeWasm() must be awaited first!");
7276 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
7277 return nativeResponseValue;
7279 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
7281 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
7282 if(!isWasmInitialized) {
7283 throw new Error("initializeWasm() must be awaited first!");
7285 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
7286 return nativeResponseValue;
7288 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
7290 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
7291 if(!isWasmInitialized) {
7292 throw new Error("initializeWasm() must be awaited first!");
7294 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
7295 return nativeResponseValue;
7297 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
7299 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
7300 if(!isWasmInitialized) {
7301 throw new Error("initializeWasm() must be awaited first!");
7303 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
7304 // debug statements here
7306 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
7308 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7309 if(!isWasmInitialized) {
7310 throw new Error("initializeWasm() must be awaited first!");
7312 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
7313 return nativeResponseValue;
7315 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
7317 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
7318 if(!isWasmInitialized) {
7319 throw new Error("initializeWasm() must be awaited first!");
7321 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7322 return nativeResponseValue;
7324 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7326 export function COption_NoneZ_some(): COption_NoneZ {
7327 if(!isWasmInitialized) {
7328 throw new Error("initializeWasm() must be awaited first!");
7330 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7331 return nativeResponseValue;
7333 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7335 export function COption_NoneZ_none(): COption_NoneZ {
7336 if(!isWasmInitialized) {
7337 throw new Error("initializeWasm() must be awaited first!");
7339 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7340 return nativeResponseValue;
7342 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7344 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7345 if(!isWasmInitialized) {
7346 throw new Error("initializeWasm() must be awaited first!");
7348 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7349 // debug statements here
7351 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7353 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
7354 if(!isWasmInitialized) {
7355 throw new Error("initializeWasm() must be awaited first!");
7357 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7358 return nativeResponseValue;
7360 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7362 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
7363 if(!isWasmInitialized) {
7364 throw new Error("initializeWasm() must be awaited first!");
7366 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7367 return nativeResponseValue;
7369 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7371 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
7372 if(!isWasmInitialized) {
7373 throw new Error("initializeWasm() must be awaited first!");
7375 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7376 return nativeResponseValue;
7378 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7380 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
7381 if(!isWasmInitialized) {
7382 throw new Error("initializeWasm() must be awaited first!");
7384 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7385 // debug statements here
7387 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7389 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7390 if(!isWasmInitialized) {
7391 throw new Error("initializeWasm() must be awaited first!");
7393 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7394 return nativeResponseValue;
7396 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7398 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
7399 if(!isWasmInitialized) {
7400 throw new Error("initializeWasm() must be awaited first!");
7402 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7403 return nativeResponseValue;
7405 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7407 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
7408 if(!isWasmInitialized) {
7409 throw new Error("initializeWasm() must be awaited first!");
7411 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7412 return nativeResponseValue;
7414 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7416 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
7417 if(!isWasmInitialized) {
7418 throw new Error("initializeWasm() must be awaited first!");
7420 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7421 return nativeResponseValue;
7423 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7425 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
7426 if(!isWasmInitialized) {
7427 throw new Error("initializeWasm() must be awaited first!");
7429 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7430 return nativeResponseValue;
7432 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7434 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
7435 if(!isWasmInitialized) {
7436 throw new Error("initializeWasm() must be awaited first!");
7438 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7439 // debug statements here
7441 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7443 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7444 if(!isWasmInitialized) {
7445 throw new Error("initializeWasm() must be awaited first!");
7447 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7448 return nativeResponseValue;
7450 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7452 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
7453 if(!isWasmInitialized) {
7454 throw new Error("initializeWasm() must be awaited first!");
7456 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7457 return nativeResponseValue;
7459 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7461 export function CVec_SignatureZ_free(_res: number): void {
7462 if(!isWasmInitialized) {
7463 throw new Error("initializeWasm() must be awaited first!");
7465 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7466 // debug statements here
7468 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7470 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
7471 if(!isWasmInitialized) {
7472 throw new Error("initializeWasm() must be awaited first!");
7474 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7475 return nativeResponseValue;
7477 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7479 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
7480 if(!isWasmInitialized) {
7481 throw new Error("initializeWasm() must be awaited first!");
7483 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7484 return nativeResponseValue;
7486 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7488 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
7489 if(!isWasmInitialized) {
7490 throw new Error("initializeWasm() must be awaited first!");
7492 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7493 return nativeResponseValue;
7495 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7497 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
7498 if(!isWasmInitialized) {
7499 throw new Error("initializeWasm() must be awaited first!");
7501 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7502 // debug statements here
7504 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7506 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7507 if(!isWasmInitialized) {
7508 throw new Error("initializeWasm() must be awaited first!");
7510 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7511 return nativeResponseValue;
7513 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7515 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
7516 if(!isWasmInitialized) {
7517 throw new Error("initializeWasm() must be awaited first!");
7519 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7520 return nativeResponseValue;
7522 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7524 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
7525 if(!isWasmInitialized) {
7526 throw new Error("initializeWasm() must be awaited first!");
7528 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7529 return nativeResponseValue;
7531 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7533 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
7534 if(!isWasmInitialized) {
7535 throw new Error("initializeWasm() must be awaited first!");
7537 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7538 return nativeResponseValue;
7540 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7542 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
7543 if(!isWasmInitialized) {
7544 throw new Error("initializeWasm() must be awaited first!");
7546 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7547 return nativeResponseValue;
7549 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7551 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
7552 if(!isWasmInitialized) {
7553 throw new Error("initializeWasm() must be awaited first!");
7555 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7556 // debug statements here
7558 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7560 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7561 if(!isWasmInitialized) {
7562 throw new Error("initializeWasm() must be awaited first!");
7564 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7565 return nativeResponseValue;
7567 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7569 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
7570 if(!isWasmInitialized) {
7571 throw new Error("initializeWasm() must be awaited first!");
7573 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7574 return nativeResponseValue;
7576 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7578 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
7579 if(!isWasmInitialized) {
7580 throw new Error("initializeWasm() must be awaited first!");
7582 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7583 return nativeResponseValue;
7585 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7587 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
7588 if(!isWasmInitialized) {
7589 throw new Error("initializeWasm() must be awaited first!");
7591 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7592 return nativeResponseValue;
7594 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7596 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
7597 if(!isWasmInitialized) {
7598 throw new Error("initializeWasm() must be awaited first!");
7600 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7601 return nativeResponseValue;
7603 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7605 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
7606 if(!isWasmInitialized) {
7607 throw new Error("initializeWasm() must be awaited first!");
7609 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7610 // debug statements here
7612 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7614 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
7615 if(!isWasmInitialized) {
7616 throw new Error("initializeWasm() must be awaited first!");
7618 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7619 return nativeResponseValue;
7621 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7623 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
7624 if(!isWasmInitialized) {
7625 throw new Error("initializeWasm() must be awaited first!");
7627 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7628 return nativeResponseValue;
7630 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7632 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
7633 if(!isWasmInitialized) {
7634 throw new Error("initializeWasm() must be awaited first!");
7636 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7637 return nativeResponseValue;
7639 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7641 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
7642 if(!isWasmInitialized) {
7643 throw new Error("initializeWasm() must be awaited first!");
7645 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7646 // debug statements here
7648 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7650 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7651 if(!isWasmInitialized) {
7652 throw new Error("initializeWasm() must be awaited first!");
7654 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7655 return nativeResponseValue;
7657 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7659 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
7660 if(!isWasmInitialized) {
7661 throw new Error("initializeWasm() must be awaited first!");
7663 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7664 return nativeResponseValue;
7666 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7668 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
7669 if(!isWasmInitialized) {
7670 throw new Error("initializeWasm() must be awaited first!");
7672 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7673 return nativeResponseValue;
7675 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7677 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
7678 if(!isWasmInitialized) {
7679 throw new Error("initializeWasm() must be awaited first!");
7681 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7682 return nativeResponseValue;
7684 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7686 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
7687 if(!isWasmInitialized) {
7688 throw new Error("initializeWasm() must be awaited first!");
7690 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7691 return nativeResponseValue;
7693 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7695 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
7696 if(!isWasmInitialized) {
7697 throw new Error("initializeWasm() must be awaited first!");
7699 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7700 // debug statements here
7702 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7704 export function CResult_CVec_SignatureZNoneZ_ok(o: number): bigint {
7705 if(!isWasmInitialized) {
7706 throw new Error("initializeWasm() must be awaited first!");
7708 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7709 return nativeResponseValue;
7711 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7713 export function CResult_CVec_SignatureZNoneZ_err(): bigint {
7714 if(!isWasmInitialized) {
7715 throw new Error("initializeWasm() must be awaited first!");
7717 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7718 return nativeResponseValue;
7720 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7722 export function CResult_CVec_SignatureZNoneZ_is_ok(o: bigint): boolean {
7723 if(!isWasmInitialized) {
7724 throw new Error("initializeWasm() must be awaited first!");
7726 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7727 return nativeResponseValue;
7729 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7731 export function CResult_CVec_SignatureZNoneZ_free(_res: bigint): void {
7732 if(!isWasmInitialized) {
7733 throw new Error("initializeWasm() must be awaited first!");
7735 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7736 // debug statements here
7738 // uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7740 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: bigint): bigint {
7741 if(!isWasmInitialized) {
7742 throw new Error("initializeWasm() must be awaited first!");
7744 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7745 return nativeResponseValue;
7747 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7749 export function CResult_CVec_SignatureZNoneZ_clone(orig: bigint): bigint {
7750 if(!isWasmInitialized) {
7751 throw new Error("initializeWasm() must be awaited first!");
7753 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7754 return nativeResponseValue;
7756 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7758 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
7759 if(!isWasmInitialized) {
7760 throw new Error("initializeWasm() must be awaited first!");
7762 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7763 return nativeResponseValue;
7765 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7767 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
7768 if(!isWasmInitialized) {
7769 throw new Error("initializeWasm() must be awaited first!");
7771 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7772 return nativeResponseValue;
7774 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7776 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
7777 if(!isWasmInitialized) {
7778 throw new Error("initializeWasm() must be awaited first!");
7780 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7781 return nativeResponseValue;
7783 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7785 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
7786 if(!isWasmInitialized) {
7787 throw new Error("initializeWasm() must be awaited first!");
7789 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7790 // debug statements here
7792 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7794 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7795 if(!isWasmInitialized) {
7796 throw new Error("initializeWasm() must be awaited first!");
7798 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7799 return nativeResponseValue;
7801 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7803 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
7804 if(!isWasmInitialized) {
7805 throw new Error("initializeWasm() must be awaited first!");
7807 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7808 return nativeResponseValue;
7810 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7812 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
7813 if(!isWasmInitialized) {
7814 throw new Error("initializeWasm() must be awaited first!");
7816 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7817 return nativeResponseValue;
7819 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7821 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
7822 if(!isWasmInitialized) {
7823 throw new Error("initializeWasm() must be awaited first!");
7825 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7826 return nativeResponseValue;
7828 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7830 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
7831 if(!isWasmInitialized) {
7832 throw new Error("initializeWasm() must be awaited first!");
7834 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7835 return nativeResponseValue;
7837 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7839 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
7840 if(!isWasmInitialized) {
7841 throw new Error("initializeWasm() must be awaited first!");
7843 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7844 // debug statements here
7846 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7848 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
7849 if(!isWasmInitialized) {
7850 throw new Error("initializeWasm() must be awaited first!");
7852 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7853 return nativeResponseValue;
7855 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7857 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
7858 if(!isWasmInitialized) {
7859 throw new Error("initializeWasm() must be awaited first!");
7861 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7862 return nativeResponseValue;
7864 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7866 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
7867 if(!isWasmInitialized) {
7868 throw new Error("initializeWasm() must be awaited first!");
7870 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7871 return nativeResponseValue;
7873 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7875 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
7876 if(!isWasmInitialized) {
7877 throw new Error("initializeWasm() must be awaited first!");
7879 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7880 return nativeResponseValue;
7882 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7884 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
7885 if(!isWasmInitialized) {
7886 throw new Error("initializeWasm() must be awaited first!");
7888 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7889 return nativeResponseValue;
7891 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7893 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
7894 if(!isWasmInitialized) {
7895 throw new Error("initializeWasm() must be awaited first!");
7897 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7898 // debug statements here
7900 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7902 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7903 if(!isWasmInitialized) {
7904 throw new Error("initializeWasm() must be awaited first!");
7906 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7907 return nativeResponseValue;
7909 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7911 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
7912 if(!isWasmInitialized) {
7913 throw new Error("initializeWasm() must be awaited first!");
7915 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7916 return nativeResponseValue;
7918 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7920 export function CVec_RouteHopZ_free(_res: number): void {
7921 if(!isWasmInitialized) {
7922 throw new Error("initializeWasm() must be awaited first!");
7924 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7925 // debug statements here
7927 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7929 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7930 if(!isWasmInitialized) {
7931 throw new Error("initializeWasm() must be awaited first!");
7933 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7934 // debug statements here
7936 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7938 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
7939 if(!isWasmInitialized) {
7940 throw new Error("initializeWasm() must be awaited first!");
7942 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7943 return nativeResponseValue;
7945 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7947 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
7948 if(!isWasmInitialized) {
7949 throw new Error("initializeWasm() must be awaited first!");
7951 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7952 return nativeResponseValue;
7954 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7956 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
7957 if(!isWasmInitialized) {
7958 throw new Error("initializeWasm() must be awaited first!");
7960 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7961 return nativeResponseValue;
7963 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7965 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
7966 if(!isWasmInitialized) {
7967 throw new Error("initializeWasm() must be awaited first!");
7969 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7970 // debug statements here
7972 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7974 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
7975 if(!isWasmInitialized) {
7976 throw new Error("initializeWasm() must be awaited first!");
7978 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7979 return nativeResponseValue;
7981 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7983 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
7984 if(!isWasmInitialized) {
7985 throw new Error("initializeWasm() must be awaited first!");
7987 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7988 return nativeResponseValue;
7990 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7992 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
7993 if(!isWasmInitialized) {
7994 throw new Error("initializeWasm() must be awaited first!");
7996 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7997 return nativeResponseValue;
7999 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
8001 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
8002 if(!isWasmInitialized) {
8003 throw new Error("initializeWasm() must be awaited first!");
8005 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
8006 return nativeResponseValue;
8008 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
8010 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8011 if(!isWasmInitialized) {
8012 throw new Error("initializeWasm() must be awaited first!");
8014 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
8015 return nativeResponseValue;
8017 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
8019 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
8020 if(!isWasmInitialized) {
8021 throw new Error("initializeWasm() must be awaited first!");
8023 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
8024 // debug statements here
8026 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
8028 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8029 if(!isWasmInitialized) {
8030 throw new Error("initializeWasm() must be awaited first!");
8032 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
8033 return nativeResponseValue;
8035 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
8037 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
8038 if(!isWasmInitialized) {
8039 throw new Error("initializeWasm() must be awaited first!");
8041 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
8042 return nativeResponseValue;
8044 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
8046 export function CVec_RouteHintZ_free(_res: number): void {
8047 if(!isWasmInitialized) {
8048 throw new Error("initializeWasm() must be awaited first!");
8050 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
8051 // debug statements here
8053 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
8055 export function COption_u64Z_some(o: bigint): bigint {
8056 if(!isWasmInitialized) {
8057 throw new Error("initializeWasm() must be awaited first!");
8059 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
8060 return nativeResponseValue;
8062 // struct LDKCOption_u64Z COption_u64Z_none(void);
8064 export function COption_u64Z_none(): bigint {
8065 if(!isWasmInitialized) {
8066 throw new Error("initializeWasm() must be awaited first!");
8068 const nativeResponseValue = wasm.TS_COption_u64Z_none();
8069 return nativeResponseValue;
8071 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
8073 export function COption_u64Z_free(_res: bigint): void {
8074 if(!isWasmInitialized) {
8075 throw new Error("initializeWasm() must be awaited first!");
8077 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
8078 // debug statements here
8080 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
8082 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
8083 if(!isWasmInitialized) {
8084 throw new Error("initializeWasm() must be awaited first!");
8086 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
8087 return nativeResponseValue;
8089 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
8091 export function COption_u64Z_clone(orig: bigint): bigint {
8092 if(!isWasmInitialized) {
8093 throw new Error("initializeWasm() must be awaited first!");
8095 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
8096 return nativeResponseValue;
8098 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8100 export function CVec_u64Z_free(_res: number): void {
8101 if(!isWasmInitialized) {
8102 throw new Error("initializeWasm() must be awaited first!");
8104 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8105 // debug statements here
8107 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
8109 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
8110 if(!isWasmInitialized) {
8111 throw new Error("initializeWasm() must be awaited first!");
8113 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
8114 return nativeResponseValue;
8116 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
8118 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
8119 if(!isWasmInitialized) {
8120 throw new Error("initializeWasm() must be awaited first!");
8122 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
8123 return nativeResponseValue;
8125 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
8127 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
8128 if(!isWasmInitialized) {
8129 throw new Error("initializeWasm() must be awaited first!");
8131 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
8132 return nativeResponseValue;
8134 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
8136 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
8137 if(!isWasmInitialized) {
8138 throw new Error("initializeWasm() must be awaited first!");
8140 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
8141 // debug statements here
8143 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
8145 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8146 if(!isWasmInitialized) {
8147 throw new Error("initializeWasm() must be awaited first!");
8149 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
8150 return nativeResponseValue;
8152 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
8154 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
8155 if(!isWasmInitialized) {
8156 throw new Error("initializeWasm() must be awaited first!");
8158 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
8159 return nativeResponseValue;
8161 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
8163 export function CVec_RouteHintHopZ_free(_res: number): void {
8164 if(!isWasmInitialized) {
8165 throw new Error("initializeWasm() must be awaited first!");
8167 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
8168 // debug statements here
8170 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
8172 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
8173 if(!isWasmInitialized) {
8174 throw new Error("initializeWasm() must be awaited first!");
8176 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
8177 return nativeResponseValue;
8179 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
8181 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
8182 if(!isWasmInitialized) {
8183 throw new Error("initializeWasm() must be awaited first!");
8185 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
8186 return nativeResponseValue;
8188 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
8190 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
8191 if(!isWasmInitialized) {
8192 throw new Error("initializeWasm() must be awaited first!");
8194 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
8195 return nativeResponseValue;
8197 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
8199 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
8200 if(!isWasmInitialized) {
8201 throw new Error("initializeWasm() must be awaited first!");
8203 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
8204 // debug statements here
8206 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
8208 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8209 if(!isWasmInitialized) {
8210 throw new Error("initializeWasm() must be awaited first!");
8212 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
8213 return nativeResponseValue;
8215 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
8217 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
8218 if(!isWasmInitialized) {
8219 throw new Error("initializeWasm() must be awaited first!");
8221 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
8222 return nativeResponseValue;
8224 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
8226 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
8227 if(!isWasmInitialized) {
8228 throw new Error("initializeWasm() must be awaited first!");
8230 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
8231 return nativeResponseValue;
8233 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
8235 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
8236 if(!isWasmInitialized) {
8237 throw new Error("initializeWasm() must be awaited first!");
8239 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
8240 return nativeResponseValue;
8242 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
8244 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
8245 if(!isWasmInitialized) {
8246 throw new Error("initializeWasm() must be awaited first!");
8248 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
8249 return nativeResponseValue;
8251 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
8253 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
8254 if(!isWasmInitialized) {
8255 throw new Error("initializeWasm() must be awaited first!");
8257 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
8258 // debug statements here
8260 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
8262 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8263 if(!isWasmInitialized) {
8264 throw new Error("initializeWasm() must be awaited first!");
8266 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
8267 return nativeResponseValue;
8269 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
8271 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
8272 if(!isWasmInitialized) {
8273 throw new Error("initializeWasm() must be awaited first!");
8275 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
8276 return nativeResponseValue;
8278 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8280 export function CVec_ChannelDetailsZ_free(_res: number): void {
8281 if(!isWasmInitialized) {
8282 throw new Error("initializeWasm() must be awaited first!");
8284 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8285 // debug statements here
8287 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8289 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
8290 if(!isWasmInitialized) {
8291 throw new Error("initializeWasm() must be awaited first!");
8293 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8294 return nativeResponseValue;
8296 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8298 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
8299 if(!isWasmInitialized) {
8300 throw new Error("initializeWasm() must be awaited first!");
8302 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8303 return nativeResponseValue;
8305 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8307 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
8308 if(!isWasmInitialized) {
8309 throw new Error("initializeWasm() must be awaited first!");
8311 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8312 return nativeResponseValue;
8314 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8316 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
8317 if(!isWasmInitialized) {
8318 throw new Error("initializeWasm() must be awaited first!");
8320 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8321 // debug statements here
8323 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8325 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
8326 if(!isWasmInitialized) {
8327 throw new Error("initializeWasm() must be awaited first!");
8329 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8330 return nativeResponseValue;
8332 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8334 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
8335 if(!isWasmInitialized) {
8336 throw new Error("initializeWasm() must be awaited first!");
8338 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8339 return nativeResponseValue;
8341 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8343 export function CVec_PublicKeyZ_free(_res: number): void {
8344 if(!isWasmInitialized) {
8345 throw new Error("initializeWasm() must be awaited first!");
8347 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8348 // debug statements here
8350 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8352 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
8353 if(!isWasmInitialized) {
8354 throw new Error("initializeWasm() must be awaited first!");
8356 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8357 return nativeResponseValue;
8359 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8361 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
8362 if(!isWasmInitialized) {
8363 throw new Error("initializeWasm() must be awaited first!");
8365 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8366 return nativeResponseValue;
8368 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8370 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
8371 if(!isWasmInitialized) {
8372 throw new Error("initializeWasm() must be awaited first!");
8374 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8375 return nativeResponseValue;
8377 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8379 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
8380 if(!isWasmInitialized) {
8381 throw new Error("initializeWasm() must be awaited first!");
8383 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8384 // debug statements here
8386 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8388 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8389 if(!isWasmInitialized) {
8390 throw new Error("initializeWasm() must be awaited first!");
8392 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8393 return nativeResponseValue;
8395 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8397 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
8398 if(!isWasmInitialized) {
8399 throw new Error("initializeWasm() must be awaited first!");
8401 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8402 return nativeResponseValue;
8404 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8406 export function COption_ClosureReasonZ_some(o: bigint): bigint {
8407 if(!isWasmInitialized) {
8408 throw new Error("initializeWasm() must be awaited first!");
8410 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8411 return nativeResponseValue;
8413 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8415 export function COption_ClosureReasonZ_none(): bigint {
8416 if(!isWasmInitialized) {
8417 throw new Error("initializeWasm() must be awaited first!");
8419 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8420 return nativeResponseValue;
8422 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8424 export function COption_ClosureReasonZ_free(_res: bigint): void {
8425 if(!isWasmInitialized) {
8426 throw new Error("initializeWasm() must be awaited first!");
8428 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8429 // debug statements here
8431 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8433 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
8434 if(!isWasmInitialized) {
8435 throw new Error("initializeWasm() must be awaited first!");
8437 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8438 return nativeResponseValue;
8440 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8442 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
8443 if(!isWasmInitialized) {
8444 throw new Error("initializeWasm() must be awaited first!");
8446 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8447 return nativeResponseValue;
8449 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8451 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
8452 if(!isWasmInitialized) {
8453 throw new Error("initializeWasm() must be awaited first!");
8455 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8456 return nativeResponseValue;
8458 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8460 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
8461 if(!isWasmInitialized) {
8462 throw new Error("initializeWasm() must be awaited first!");
8464 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8465 return nativeResponseValue;
8467 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8469 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
8470 if(!isWasmInitialized) {
8471 throw new Error("initializeWasm() must be awaited first!");
8473 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8474 return nativeResponseValue;
8476 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8478 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
8479 if(!isWasmInitialized) {
8480 throw new Error("initializeWasm() must be awaited first!");
8482 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8483 // debug statements here
8485 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8487 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8488 if(!isWasmInitialized) {
8489 throw new Error("initializeWasm() must be awaited first!");
8491 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8492 return nativeResponseValue;
8494 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8496 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
8497 if(!isWasmInitialized) {
8498 throw new Error("initializeWasm() must be awaited first!");
8500 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8501 return nativeResponseValue;
8503 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
8505 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
8506 if(!isWasmInitialized) {
8507 throw new Error("initializeWasm() must be awaited first!");
8509 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
8510 return nativeResponseValue;
8512 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
8514 export function COption_HTLCDestinationZ_none(): bigint {
8515 if(!isWasmInitialized) {
8516 throw new Error("initializeWasm() must be awaited first!");
8518 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
8519 return nativeResponseValue;
8521 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
8523 export function COption_HTLCDestinationZ_free(_res: bigint): void {
8524 if(!isWasmInitialized) {
8525 throw new Error("initializeWasm() must be awaited first!");
8527 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
8528 // debug statements here
8530 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
8532 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
8533 if(!isWasmInitialized) {
8534 throw new Error("initializeWasm() must be awaited first!");
8536 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
8537 return nativeResponseValue;
8539 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
8541 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
8542 if(!isWasmInitialized) {
8543 throw new Error("initializeWasm() must be awaited first!");
8545 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
8546 return nativeResponseValue;
8548 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
8550 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
8551 if(!isWasmInitialized) {
8552 throw new Error("initializeWasm() must be awaited first!");
8554 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
8555 return nativeResponseValue;
8557 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
8559 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
8560 if(!isWasmInitialized) {
8561 throw new Error("initializeWasm() must be awaited first!");
8563 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
8564 return nativeResponseValue;
8566 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
8568 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
8569 if(!isWasmInitialized) {
8570 throw new Error("initializeWasm() must be awaited first!");
8572 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
8573 return nativeResponseValue;
8575 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
8577 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
8578 if(!isWasmInitialized) {
8579 throw new Error("initializeWasm() must be awaited first!");
8581 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
8582 // debug statements here
8584 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
8586 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8587 if(!isWasmInitialized) {
8588 throw new Error("initializeWasm() must be awaited first!");
8590 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
8591 return nativeResponseValue;
8593 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
8595 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
8596 if(!isWasmInitialized) {
8597 throw new Error("initializeWasm() must be awaited first!");
8599 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
8600 return nativeResponseValue;
8602 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8604 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
8605 if(!isWasmInitialized) {
8606 throw new Error("initializeWasm() must be awaited first!");
8608 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8609 return nativeResponseValue;
8611 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8613 export function COption_NetworkUpdateZ_none(): bigint {
8614 if(!isWasmInitialized) {
8615 throw new Error("initializeWasm() must be awaited first!");
8617 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8618 return nativeResponseValue;
8620 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8622 export function COption_NetworkUpdateZ_free(_res: bigint): void {
8623 if(!isWasmInitialized) {
8624 throw new Error("initializeWasm() must be awaited first!");
8626 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8627 // debug statements here
8629 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8631 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
8632 if(!isWasmInitialized) {
8633 throw new Error("initializeWasm() must be awaited first!");
8635 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8636 return nativeResponseValue;
8638 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8640 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
8641 if(!isWasmInitialized) {
8642 throw new Error("initializeWasm() must be awaited first!");
8644 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8645 return nativeResponseValue;
8647 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8649 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8650 if(!isWasmInitialized) {
8651 throw new Error("initializeWasm() must be awaited first!");
8653 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8654 // debug statements here
8656 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8658 export function COption_EventZ_some(o: bigint): bigint {
8659 if(!isWasmInitialized) {
8660 throw new Error("initializeWasm() must be awaited first!");
8662 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8663 return nativeResponseValue;
8665 // struct LDKCOption_EventZ COption_EventZ_none(void);
8667 export function COption_EventZ_none(): bigint {
8668 if(!isWasmInitialized) {
8669 throw new Error("initializeWasm() must be awaited first!");
8671 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8672 return nativeResponseValue;
8674 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8676 export function COption_EventZ_free(_res: bigint): void {
8677 if(!isWasmInitialized) {
8678 throw new Error("initializeWasm() must be awaited first!");
8680 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8681 // debug statements here
8683 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8685 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
8686 if(!isWasmInitialized) {
8687 throw new Error("initializeWasm() must be awaited first!");
8689 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8690 return nativeResponseValue;
8692 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8694 export function COption_EventZ_clone(orig: bigint): bigint {
8695 if(!isWasmInitialized) {
8696 throw new Error("initializeWasm() must be awaited first!");
8698 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8699 return nativeResponseValue;
8701 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8703 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
8704 if(!isWasmInitialized) {
8705 throw new Error("initializeWasm() must be awaited first!");
8707 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8708 return nativeResponseValue;
8710 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8712 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
8713 if(!isWasmInitialized) {
8714 throw new Error("initializeWasm() must be awaited first!");
8716 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8717 return nativeResponseValue;
8719 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8721 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
8722 if(!isWasmInitialized) {
8723 throw new Error("initializeWasm() must be awaited first!");
8725 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8726 return nativeResponseValue;
8728 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8730 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
8731 if(!isWasmInitialized) {
8732 throw new Error("initializeWasm() must be awaited first!");
8734 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8735 // debug statements here
8737 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8739 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
8740 if(!isWasmInitialized) {
8741 throw new Error("initializeWasm() must be awaited first!");
8743 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8744 return nativeResponseValue;
8746 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8748 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
8749 if(!isWasmInitialized) {
8750 throw new Error("initializeWasm() must be awaited first!");
8752 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8753 return nativeResponseValue;
8755 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8757 export function CVec_MessageSendEventZ_free(_res: number): void {
8758 if(!isWasmInitialized) {
8759 throw new Error("initializeWasm() must be awaited first!");
8761 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8762 // debug statements here
8764 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8766 export function CResult_TxOutAccessErrorZ_ok(o: bigint): bigint {
8767 if(!isWasmInitialized) {
8768 throw new Error("initializeWasm() must be awaited first!");
8770 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8771 return nativeResponseValue;
8773 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8775 export function CResult_TxOutAccessErrorZ_err(e: AccessError): bigint {
8776 if(!isWasmInitialized) {
8777 throw new Error("initializeWasm() must be awaited first!");
8779 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8780 return nativeResponseValue;
8782 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8784 export function CResult_TxOutAccessErrorZ_is_ok(o: bigint): boolean {
8785 if(!isWasmInitialized) {
8786 throw new Error("initializeWasm() must be awaited first!");
8788 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8789 return nativeResponseValue;
8791 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8793 export function CResult_TxOutAccessErrorZ_free(_res: bigint): void {
8794 if(!isWasmInitialized) {
8795 throw new Error("initializeWasm() must be awaited first!");
8797 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8798 // debug statements here
8800 // uint64_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8802 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: bigint): bigint {
8803 if(!isWasmInitialized) {
8804 throw new Error("initializeWasm() must be awaited first!");
8806 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8807 return nativeResponseValue;
8809 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8811 export function CResult_TxOutAccessErrorZ_clone(orig: bigint): bigint {
8812 if(!isWasmInitialized) {
8813 throw new Error("initializeWasm() must be awaited first!");
8815 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8816 return nativeResponseValue;
8818 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8820 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
8821 if(!isWasmInitialized) {
8822 throw new Error("initializeWasm() must be awaited first!");
8824 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8825 return nativeResponseValue;
8827 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8829 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
8830 if(!isWasmInitialized) {
8831 throw new Error("initializeWasm() must be awaited first!");
8833 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8834 return nativeResponseValue;
8836 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8838 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
8839 if(!isWasmInitialized) {
8840 throw new Error("initializeWasm() must be awaited first!");
8842 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8843 return nativeResponseValue;
8845 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8847 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
8848 if(!isWasmInitialized) {
8849 throw new Error("initializeWasm() must be awaited first!");
8851 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8852 // debug statements here
8854 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8856 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8857 if(!isWasmInitialized) {
8858 throw new Error("initializeWasm() must be awaited first!");
8860 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8861 // debug statements here
8863 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8865 export function CVec_TxidZ_free(_res: number): void {
8866 if(!isWasmInitialized) {
8867 throw new Error("initializeWasm() must be awaited first!");
8869 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8870 // debug statements here
8872 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8874 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): bigint {
8875 if(!isWasmInitialized) {
8876 throw new Error("initializeWasm() must be awaited first!");
8878 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8879 return nativeResponseValue;
8881 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8883 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): bigint {
8884 if(!isWasmInitialized) {
8885 throw new Error("initializeWasm() must be awaited first!");
8887 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8888 return nativeResponseValue;
8890 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8892 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: bigint): boolean {
8893 if(!isWasmInitialized) {
8894 throw new Error("initializeWasm() must be awaited first!");
8896 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8897 return nativeResponseValue;
8899 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8901 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: bigint): void {
8902 if(!isWasmInitialized) {
8903 throw new Error("initializeWasm() must be awaited first!");
8905 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8906 // debug statements here
8908 // uint64_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8910 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: bigint): bigint {
8911 if(!isWasmInitialized) {
8912 throw new Error("initializeWasm() must be awaited first!");
8914 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8915 return nativeResponseValue;
8917 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8919 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: bigint): bigint {
8920 if(!isWasmInitialized) {
8921 throw new Error("initializeWasm() must be awaited first!");
8923 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8924 return nativeResponseValue;
8926 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8928 export function CVec_MonitorEventZ_free(_res: number): void {
8929 if(!isWasmInitialized) {
8930 throw new Error("initializeWasm() must be awaited first!");
8932 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8933 // debug statements here
8935 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
8937 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
8938 if(!isWasmInitialized) {
8939 throw new Error("initializeWasm() must be awaited first!");
8941 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
8942 return nativeResponseValue;
8944 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
8946 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
8947 if(!isWasmInitialized) {
8948 throw new Error("initializeWasm() must be awaited first!");
8950 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
8951 return nativeResponseValue;
8953 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
8955 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
8956 if(!isWasmInitialized) {
8957 throw new Error("initializeWasm() must be awaited first!");
8959 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
8960 return nativeResponseValue;
8962 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
8964 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
8965 if(!isWasmInitialized) {
8966 throw new Error("initializeWasm() must be awaited first!");
8968 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
8969 // debug statements here
8971 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
8973 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
8974 if(!isWasmInitialized) {
8975 throw new Error("initializeWasm() must be awaited first!");
8977 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
8978 // debug statements here
8980 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8982 export function COption_C2Tuple_usizeTransactionZZ_some(o: bigint): bigint {
8983 if(!isWasmInitialized) {
8984 throw new Error("initializeWasm() must be awaited first!");
8986 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8987 return nativeResponseValue;
8989 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8991 export function COption_C2Tuple_usizeTransactionZZ_none(): bigint {
8992 if(!isWasmInitialized) {
8993 throw new Error("initializeWasm() must be awaited first!");
8995 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8996 return nativeResponseValue;
8998 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
9000 export function COption_C2Tuple_usizeTransactionZZ_free(_res: bigint): void {
9001 if(!isWasmInitialized) {
9002 throw new Error("initializeWasm() must be awaited first!");
9004 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
9005 // debug statements here
9007 // uint64_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
9009 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: bigint): bigint {
9010 if(!isWasmInitialized) {
9011 throw new Error("initializeWasm() must be awaited first!");
9013 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
9014 return nativeResponseValue;
9016 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
9018 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: bigint): bigint {
9019 if(!isWasmInitialized) {
9020 throw new Error("initializeWasm() must be awaited first!");
9022 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
9023 return nativeResponseValue;
9025 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
9027 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
9028 if(!isWasmInitialized) {
9029 throw new Error("initializeWasm() must be awaited first!");
9031 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
9032 return nativeResponseValue;
9034 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
9036 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
9037 if(!isWasmInitialized) {
9038 throw new Error("initializeWasm() must be awaited first!");
9040 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
9041 return nativeResponseValue;
9043 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
9045 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
9046 if(!isWasmInitialized) {
9047 throw new Error("initializeWasm() must be awaited first!");
9049 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
9050 return nativeResponseValue;
9052 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
9054 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
9055 if(!isWasmInitialized) {
9056 throw new Error("initializeWasm() must be awaited first!");
9058 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
9059 // debug statements here
9061 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
9063 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9064 if(!isWasmInitialized) {
9065 throw new Error("initializeWasm() must be awaited first!");
9067 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
9068 return nativeResponseValue;
9070 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
9072 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
9073 if(!isWasmInitialized) {
9074 throw new Error("initializeWasm() must be awaited first!");
9076 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
9077 return nativeResponseValue;
9079 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
9081 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
9082 if(!isWasmInitialized) {
9083 throw new Error("initializeWasm() must be awaited first!");
9085 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
9086 return nativeResponseValue;
9088 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
9090 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
9091 if(!isWasmInitialized) {
9092 throw new Error("initializeWasm() must be awaited first!");
9094 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
9095 return nativeResponseValue;
9097 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
9099 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
9100 if(!isWasmInitialized) {
9101 throw new Error("initializeWasm() must be awaited first!");
9103 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
9104 return nativeResponseValue;
9106 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
9108 export function C2Tuple_u64u64Z_free(_res: bigint): void {
9109 if(!isWasmInitialized) {
9110 throw new Error("initializeWasm() must be awaited first!");
9112 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
9113 // debug statements here
9115 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
9117 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
9118 if(!isWasmInitialized) {
9119 throw new Error("initializeWasm() must be awaited first!");
9121 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
9122 return nativeResponseValue;
9124 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
9126 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
9127 if(!isWasmInitialized) {
9128 throw new Error("initializeWasm() must be awaited first!");
9130 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
9131 return nativeResponseValue;
9133 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
9135 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
9136 if(!isWasmInitialized) {
9137 throw new Error("initializeWasm() must be awaited first!");
9139 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
9140 // debug statements here
9142 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
9144 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
9145 if(!isWasmInitialized) {
9146 throw new Error("initializeWasm() must be awaited first!");
9148 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
9149 return nativeResponseValue;
9151 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
9153 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
9154 if(!isWasmInitialized) {
9155 throw new Error("initializeWasm() must be awaited first!");
9157 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
9158 return nativeResponseValue;
9160 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
9162 export function CVec_NodeIdZ_free(_res: number): void {
9163 if(!isWasmInitialized) {
9164 throw new Error("initializeWasm() must be awaited first!");
9166 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
9167 // debug statements here
9169 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
9171 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
9172 if(!isWasmInitialized) {
9173 throw new Error("initializeWasm() must be awaited first!");
9175 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
9176 return nativeResponseValue;
9178 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
9180 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
9181 if(!isWasmInitialized) {
9182 throw new Error("initializeWasm() must be awaited first!");
9184 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
9185 return nativeResponseValue;
9187 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
9189 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
9190 if(!isWasmInitialized) {
9191 throw new Error("initializeWasm() must be awaited first!");
9193 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
9194 return nativeResponseValue;
9196 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
9198 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
9199 if(!isWasmInitialized) {
9200 throw new Error("initializeWasm() must be awaited first!");
9202 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
9203 // debug statements here
9205 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
9207 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9208 if(!isWasmInitialized) {
9209 throw new Error("initializeWasm() must be awaited first!");
9211 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
9212 return nativeResponseValue;
9214 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9216 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
9217 if(!isWasmInitialized) {
9218 throw new Error("initializeWasm() must be awaited first!");
9220 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
9221 return nativeResponseValue;
9223 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
9225 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9226 if(!isWasmInitialized) {
9227 throw new Error("initializeWasm() must be awaited first!");
9229 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
9230 return nativeResponseValue;
9232 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
9234 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
9235 if(!isWasmInitialized) {
9236 throw new Error("initializeWasm() must be awaited first!");
9238 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
9239 // debug statements here
9241 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
9243 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9244 if(!isWasmInitialized) {
9245 throw new Error("initializeWasm() must be awaited first!");
9247 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
9248 return nativeResponseValue;
9250 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
9252 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9253 if(!isWasmInitialized) {
9254 throw new Error("initializeWasm() must be awaited first!");
9256 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
9257 return nativeResponseValue;
9259 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
9261 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9262 if(!isWasmInitialized) {
9263 throw new Error("initializeWasm() must be awaited first!");
9265 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
9266 return nativeResponseValue;
9268 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9270 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
9271 if(!isWasmInitialized) {
9272 throw new Error("initializeWasm() must be awaited first!");
9274 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
9275 return nativeResponseValue;
9277 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
9279 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9280 if(!isWasmInitialized) {
9281 throw new Error("initializeWasm() must be awaited first!");
9283 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
9284 return nativeResponseValue;
9286 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
9288 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
9289 if(!isWasmInitialized) {
9290 throw new Error("initializeWasm() must be awaited first!");
9292 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
9293 // debug statements here
9295 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
9297 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9298 if(!isWasmInitialized) {
9299 throw new Error("initializeWasm() must be awaited first!");
9301 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
9302 return nativeResponseValue;
9304 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
9306 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9307 if(!isWasmInitialized) {
9308 throw new Error("initializeWasm() must be awaited first!");
9310 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
9311 return nativeResponseValue;
9313 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
9315 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9316 if(!isWasmInitialized) {
9317 throw new Error("initializeWasm() must be awaited first!");
9319 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
9320 return nativeResponseValue;
9322 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9324 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
9325 if(!isWasmInitialized) {
9326 throw new Error("initializeWasm() must be awaited first!");
9328 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
9329 return nativeResponseValue;
9331 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
9333 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9334 if(!isWasmInitialized) {
9335 throw new Error("initializeWasm() must be awaited first!");
9337 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
9338 return nativeResponseValue;
9340 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
9342 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
9343 if(!isWasmInitialized) {
9344 throw new Error("initializeWasm() must be awaited first!");
9346 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
9347 // debug statements here
9349 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9351 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9352 if(!isWasmInitialized) {
9353 throw new Error("initializeWasm() must be awaited first!");
9355 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
9356 return nativeResponseValue;
9358 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9360 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9361 if(!isWasmInitialized) {
9362 throw new Error("initializeWasm() must be awaited first!");
9364 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
9365 return nativeResponseValue;
9367 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
9369 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9370 if(!isWasmInitialized) {
9371 throw new Error("initializeWasm() must be awaited first!");
9373 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
9374 return nativeResponseValue;
9376 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9378 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
9379 if(!isWasmInitialized) {
9380 throw new Error("initializeWasm() must be awaited first!");
9382 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
9383 return nativeResponseValue;
9385 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
9387 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9388 if(!isWasmInitialized) {
9389 throw new Error("initializeWasm() must be awaited first!");
9391 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
9392 return nativeResponseValue;
9394 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
9396 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
9397 if(!isWasmInitialized) {
9398 throw new Error("initializeWasm() must be awaited first!");
9400 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
9401 // debug statements here
9403 // uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
9405 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9406 if(!isWasmInitialized) {
9407 throw new Error("initializeWasm() must be awaited first!");
9409 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
9410 return nativeResponseValue;
9412 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
9414 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9415 if(!isWasmInitialized) {
9416 throw new Error("initializeWasm() must be awaited first!");
9418 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
9419 return nativeResponseValue;
9421 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
9423 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
9424 if(!isWasmInitialized) {
9425 throw new Error("initializeWasm() must be awaited first!");
9427 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
9428 return nativeResponseValue;
9430 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9432 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
9433 if(!isWasmInitialized) {
9434 throw new Error("initializeWasm() must be awaited first!");
9436 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
9437 return nativeResponseValue;
9439 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
9441 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
9442 if(!isWasmInitialized) {
9443 throw new Error("initializeWasm() must be awaited first!");
9445 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9446 return nativeResponseValue;
9448 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9450 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
9451 if(!isWasmInitialized) {
9452 throw new Error("initializeWasm() must be awaited first!");
9454 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9455 // debug statements here
9457 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9459 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9460 if(!isWasmInitialized) {
9461 throw new Error("initializeWasm() must be awaited first!");
9463 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
9464 return nativeResponseValue;
9466 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9468 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
9469 if(!isWasmInitialized) {
9470 throw new Error("initializeWasm() must be awaited first!");
9472 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
9473 return nativeResponseValue;
9475 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
9477 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
9478 if(!isWasmInitialized) {
9479 throw new Error("initializeWasm() must be awaited first!");
9481 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
9482 return nativeResponseValue;
9484 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
9486 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
9487 if(!isWasmInitialized) {
9488 throw new Error("initializeWasm() must be awaited first!");
9490 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
9491 return nativeResponseValue;
9493 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
9495 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
9496 if(!isWasmInitialized) {
9497 throw new Error("initializeWasm() must be awaited first!");
9499 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
9500 return nativeResponseValue;
9502 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
9504 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
9505 if(!isWasmInitialized) {
9506 throw new Error("initializeWasm() must be awaited first!");
9508 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
9509 // debug statements here
9511 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
9513 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9514 if(!isWasmInitialized) {
9515 throw new Error("initializeWasm() must be awaited first!");
9517 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
9518 return nativeResponseValue;
9520 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9522 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
9523 if(!isWasmInitialized) {
9524 throw new Error("initializeWasm() must be awaited first!");
9526 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9527 return nativeResponseValue;
9529 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9531 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
9532 if(!isWasmInitialized) {
9533 throw new Error("initializeWasm() must be awaited first!");
9535 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9536 return nativeResponseValue;
9538 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9540 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
9541 if(!isWasmInitialized) {
9542 throw new Error("initializeWasm() must be awaited first!");
9544 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9545 return nativeResponseValue;
9547 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9549 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
9550 if(!isWasmInitialized) {
9551 throw new Error("initializeWasm() must be awaited first!");
9553 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9554 return nativeResponseValue;
9556 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9558 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
9559 if(!isWasmInitialized) {
9560 throw new Error("initializeWasm() must be awaited first!");
9562 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9563 // debug statements here
9565 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9567 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9568 if(!isWasmInitialized) {
9569 throw new Error("initializeWasm() must be awaited first!");
9571 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9572 return nativeResponseValue;
9574 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9576 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
9577 if(!isWasmInitialized) {
9578 throw new Error("initializeWasm() must be awaited first!");
9580 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9581 return nativeResponseValue;
9583 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9585 export function COption_AccessZ_some(o: bigint): bigint {
9586 if(!isWasmInitialized) {
9587 throw new Error("initializeWasm() must be awaited first!");
9589 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9590 return nativeResponseValue;
9592 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9594 export function COption_AccessZ_none(): bigint {
9595 if(!isWasmInitialized) {
9596 throw new Error("initializeWasm() must be awaited first!");
9598 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9599 return nativeResponseValue;
9601 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9603 export function COption_AccessZ_free(_res: bigint): void {
9604 if(!isWasmInitialized) {
9605 throw new Error("initializeWasm() must be awaited first!");
9607 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9608 // debug statements here
9610 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9612 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
9613 if(!isWasmInitialized) {
9614 throw new Error("initializeWasm() must be awaited first!");
9616 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9617 return nativeResponseValue;
9619 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9621 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
9622 if(!isWasmInitialized) {
9623 throw new Error("initializeWasm() must be awaited first!");
9625 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9626 return nativeResponseValue;
9628 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9630 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
9631 if(!isWasmInitialized) {
9632 throw new Error("initializeWasm() must be awaited first!");
9634 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9635 return nativeResponseValue;
9637 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9639 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
9640 if(!isWasmInitialized) {
9641 throw new Error("initializeWasm() must be awaited first!");
9643 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9644 // debug statements here
9646 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9648 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
9649 if(!isWasmInitialized) {
9650 throw new Error("initializeWasm() must be awaited first!");
9652 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9653 return nativeResponseValue;
9655 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9657 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
9658 if(!isWasmInitialized) {
9659 throw new Error("initializeWasm() must be awaited first!");
9661 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9662 return nativeResponseValue;
9664 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9666 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
9667 if(!isWasmInitialized) {
9668 throw new Error("initializeWasm() must be awaited first!");
9670 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9671 return nativeResponseValue;
9673 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9675 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
9676 if(!isWasmInitialized) {
9677 throw new Error("initializeWasm() must be awaited first!");
9679 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9680 return nativeResponseValue;
9682 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9684 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
9685 if(!isWasmInitialized) {
9686 throw new Error("initializeWasm() must be awaited first!");
9688 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9689 return nativeResponseValue;
9691 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9693 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
9694 if(!isWasmInitialized) {
9695 throw new Error("initializeWasm() must be awaited first!");
9697 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9698 // debug statements here
9700 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9702 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9703 if(!isWasmInitialized) {
9704 throw new Error("initializeWasm() must be awaited first!");
9706 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9707 // debug statements here
9709 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9711 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9712 if(!isWasmInitialized) {
9713 throw new Error("initializeWasm() must be awaited first!");
9715 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9716 // debug statements here
9718 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9720 export function CResult_NoneLightningErrorZ_ok(): bigint {
9721 if(!isWasmInitialized) {
9722 throw new Error("initializeWasm() must be awaited first!");
9724 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9725 return nativeResponseValue;
9727 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9729 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
9730 if(!isWasmInitialized) {
9731 throw new Error("initializeWasm() must be awaited first!");
9733 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9734 return nativeResponseValue;
9736 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9738 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
9739 if(!isWasmInitialized) {
9740 throw new Error("initializeWasm() must be awaited first!");
9742 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9743 return nativeResponseValue;
9745 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9747 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
9748 if(!isWasmInitialized) {
9749 throw new Error("initializeWasm() must be awaited first!");
9751 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9752 // debug statements here
9754 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9756 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
9757 if(!isWasmInitialized) {
9758 throw new Error("initializeWasm() must be awaited first!");
9760 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9761 return nativeResponseValue;
9763 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9765 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
9766 if(!isWasmInitialized) {
9767 throw new Error("initializeWasm() must be awaited first!");
9769 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9770 return nativeResponseValue;
9772 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9774 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
9775 if(!isWasmInitialized) {
9776 throw new Error("initializeWasm() must be awaited first!");
9778 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9779 return nativeResponseValue;
9781 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9783 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
9784 if(!isWasmInitialized) {
9785 throw new Error("initializeWasm() must be awaited first!");
9787 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9788 return nativeResponseValue;
9790 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9792 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
9793 if(!isWasmInitialized) {
9794 throw new Error("initializeWasm() must be awaited first!");
9796 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9797 return nativeResponseValue;
9799 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9801 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
9802 if(!isWasmInitialized) {
9803 throw new Error("initializeWasm() must be awaited first!");
9805 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9806 // debug statements here
9808 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9810 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9811 if(!isWasmInitialized) {
9812 throw new Error("initializeWasm() must be awaited first!");
9814 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9815 return nativeResponseValue;
9817 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9819 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
9820 if(!isWasmInitialized) {
9821 throw new Error("initializeWasm() must be awaited first!");
9823 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9824 return nativeResponseValue;
9826 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9828 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
9829 if(!isWasmInitialized) {
9830 throw new Error("initializeWasm() must be awaited first!");
9832 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9833 return nativeResponseValue;
9835 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9837 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
9838 if(!isWasmInitialized) {
9839 throw new Error("initializeWasm() must be awaited first!");
9841 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9842 return nativeResponseValue;
9844 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9846 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
9847 if(!isWasmInitialized) {
9848 throw new Error("initializeWasm() must be awaited first!");
9850 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9851 return nativeResponseValue;
9853 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9855 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
9856 if(!isWasmInitialized) {
9857 throw new Error("initializeWasm() must be awaited first!");
9859 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9860 // debug statements here
9862 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9864 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9865 if(!isWasmInitialized) {
9866 throw new Error("initializeWasm() must be awaited first!");
9868 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9869 return nativeResponseValue;
9871 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9873 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
9874 if(!isWasmInitialized) {
9875 throw new Error("initializeWasm() must be awaited first!");
9877 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9878 return nativeResponseValue;
9880 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9882 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
9883 if(!isWasmInitialized) {
9884 throw new Error("initializeWasm() must be awaited first!");
9886 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9887 return nativeResponseValue;
9889 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9891 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
9892 if(!isWasmInitialized) {
9893 throw new Error("initializeWasm() must be awaited first!");
9895 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9896 return nativeResponseValue;
9898 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9900 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
9901 if(!isWasmInitialized) {
9902 throw new Error("initializeWasm() must be awaited first!");
9904 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9905 return nativeResponseValue;
9907 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9909 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
9910 if(!isWasmInitialized) {
9911 throw new Error("initializeWasm() must be awaited first!");
9913 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9914 // debug statements here
9916 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9918 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9919 if(!isWasmInitialized) {
9920 throw new Error("initializeWasm() must be awaited first!");
9922 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9923 return nativeResponseValue;
9925 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9927 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
9928 if(!isWasmInitialized) {
9929 throw new Error("initializeWasm() must be awaited first!");
9931 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9932 return nativeResponseValue;
9934 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9936 export function CVec_NetAddressZ_free(_res: number): void {
9937 if(!isWasmInitialized) {
9938 throw new Error("initializeWasm() must be awaited first!");
9940 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9941 // debug statements here
9943 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9945 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
9946 if(!isWasmInitialized) {
9947 throw new Error("initializeWasm() must be awaited first!");
9949 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9950 return nativeResponseValue;
9952 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9954 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
9955 if(!isWasmInitialized) {
9956 throw new Error("initializeWasm() must be awaited first!");
9958 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9959 return nativeResponseValue;
9961 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9963 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
9964 if(!isWasmInitialized) {
9965 throw new Error("initializeWasm() must be awaited first!");
9967 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9968 return nativeResponseValue;
9970 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9972 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
9973 if(!isWasmInitialized) {
9974 throw new Error("initializeWasm() must be awaited first!");
9976 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9977 // debug statements here
9979 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9981 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
9982 if(!isWasmInitialized) {
9983 throw new Error("initializeWasm() must be awaited first!");
9985 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9986 return nativeResponseValue;
9988 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9990 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
9991 if(!isWasmInitialized) {
9992 throw new Error("initializeWasm() must be awaited first!");
9994 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9995 return nativeResponseValue;
9997 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
9999 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
10000 if(!isWasmInitialized) {
10001 throw new Error("initializeWasm() must be awaited first!");
10003 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
10004 return nativeResponseValue;
10006 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
10008 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
10009 if(!isWasmInitialized) {
10010 throw new Error("initializeWasm() must be awaited first!");
10012 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
10013 return nativeResponseValue;
10015 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
10017 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
10018 if(!isWasmInitialized) {
10019 throw new Error("initializeWasm() must be awaited first!");
10021 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
10022 return nativeResponseValue;
10024 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
10026 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
10027 if(!isWasmInitialized) {
10028 throw new Error("initializeWasm() must be awaited first!");
10030 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
10031 // debug statements here
10033 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
10035 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10036 if(!isWasmInitialized) {
10037 throw new Error("initializeWasm() must be awaited first!");
10039 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
10040 return nativeResponseValue;
10042 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
10044 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
10045 if(!isWasmInitialized) {
10046 throw new Error("initializeWasm() must be awaited first!");
10048 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
10049 return nativeResponseValue;
10051 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
10053 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
10054 if(!isWasmInitialized) {
10055 throw new Error("initializeWasm() must be awaited first!");
10057 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
10058 return nativeResponseValue;
10060 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
10062 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
10063 if(!isWasmInitialized) {
10064 throw new Error("initializeWasm() must be awaited first!");
10066 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
10067 return nativeResponseValue;
10069 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
10071 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
10072 if(!isWasmInitialized) {
10073 throw new Error("initializeWasm() must be awaited first!");
10075 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
10076 return nativeResponseValue;
10078 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
10080 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
10081 if(!isWasmInitialized) {
10082 throw new Error("initializeWasm() must be awaited first!");
10084 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
10085 // debug statements here
10087 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
10089 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10090 if(!isWasmInitialized) {
10091 throw new Error("initializeWasm() must be awaited first!");
10093 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
10094 return nativeResponseValue;
10096 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
10098 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
10099 if(!isWasmInitialized) {
10100 throw new Error("initializeWasm() must be awaited first!");
10102 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
10103 return nativeResponseValue;
10105 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
10107 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
10108 if(!isWasmInitialized) {
10109 throw new Error("initializeWasm() must be awaited first!");
10111 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
10112 return nativeResponseValue;
10114 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
10116 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
10117 if(!isWasmInitialized) {
10118 throw new Error("initializeWasm() must be awaited first!");
10120 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
10121 return nativeResponseValue;
10123 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
10125 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
10126 if(!isWasmInitialized) {
10127 throw new Error("initializeWasm() must be awaited first!");
10129 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
10130 return nativeResponseValue;
10132 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
10134 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
10135 if(!isWasmInitialized) {
10136 throw new Error("initializeWasm() must be awaited first!");
10138 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
10139 // debug statements here
10141 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
10143 export function COption_CVec_NetAddressZZ_some(o: number): bigint {
10144 if(!isWasmInitialized) {
10145 throw new Error("initializeWasm() must be awaited first!");
10147 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
10148 return nativeResponseValue;
10150 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
10152 export function COption_CVec_NetAddressZZ_none(): bigint {
10153 if(!isWasmInitialized) {
10154 throw new Error("initializeWasm() must be awaited first!");
10156 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
10157 return nativeResponseValue;
10159 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
10161 export function COption_CVec_NetAddressZZ_free(_res: bigint): void {
10162 if(!isWasmInitialized) {
10163 throw new Error("initializeWasm() must be awaited first!");
10165 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
10166 // debug statements here
10168 // uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
10170 export function COption_CVec_NetAddressZZ_clone_ptr(arg: bigint): bigint {
10171 if(!isWasmInitialized) {
10172 throw new Error("initializeWasm() must be awaited first!");
10174 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
10175 return nativeResponseValue;
10177 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
10179 export function COption_CVec_NetAddressZZ_clone(orig: bigint): bigint {
10180 if(!isWasmInitialized) {
10181 throw new Error("initializeWasm() must be awaited first!");
10183 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
10184 return nativeResponseValue;
10186 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10188 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10189 if(!isWasmInitialized) {
10190 throw new Error("initializeWasm() must be awaited first!");
10192 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10193 return nativeResponseValue;
10195 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10197 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10198 if(!isWasmInitialized) {
10199 throw new Error("initializeWasm() must be awaited first!");
10201 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10202 return nativeResponseValue;
10204 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10206 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10207 if(!isWasmInitialized) {
10208 throw new Error("initializeWasm() must be awaited first!");
10210 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10211 return nativeResponseValue;
10213 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10215 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10216 if(!isWasmInitialized) {
10217 throw new Error("initializeWasm() must be awaited first!");
10219 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10220 // debug statements here
10222 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10224 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10225 if(!isWasmInitialized) {
10226 throw new Error("initializeWasm() must be awaited first!");
10228 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10229 return nativeResponseValue;
10231 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10233 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10234 if(!isWasmInitialized) {
10235 throw new Error("initializeWasm() must be awaited first!");
10237 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10238 return nativeResponseValue;
10240 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10242 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10243 if(!isWasmInitialized) {
10244 throw new Error("initializeWasm() must be awaited first!");
10246 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10247 return nativeResponseValue;
10249 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10251 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10252 if(!isWasmInitialized) {
10253 throw new Error("initializeWasm() must be awaited first!");
10255 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
10256 return nativeResponseValue;
10258 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10260 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10261 if(!isWasmInitialized) {
10262 throw new Error("initializeWasm() must be awaited first!");
10264 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10265 return nativeResponseValue;
10267 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
10269 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10270 if(!isWasmInitialized) {
10271 throw new Error("initializeWasm() must be awaited first!");
10273 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
10274 // debug statements here
10276 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10278 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10279 if(!isWasmInitialized) {
10280 throw new Error("initializeWasm() must be awaited first!");
10282 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10283 return nativeResponseValue;
10285 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10287 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10288 if(!isWasmInitialized) {
10289 throw new Error("initializeWasm() must be awaited first!");
10291 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10292 return nativeResponseValue;
10294 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
10296 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
10297 if(!isWasmInitialized) {
10298 throw new Error("initializeWasm() must be awaited first!");
10300 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
10301 return nativeResponseValue;
10303 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10305 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
10306 if(!isWasmInitialized) {
10307 throw new Error("initializeWasm() must be awaited first!");
10309 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
10310 return nativeResponseValue;
10312 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10314 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
10315 if(!isWasmInitialized) {
10316 throw new Error("initializeWasm() must be awaited first!");
10318 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
10319 return nativeResponseValue;
10321 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
10323 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
10324 if(!isWasmInitialized) {
10325 throw new Error("initializeWasm() must be awaited first!");
10327 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10328 // debug statements here
10330 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10332 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10333 if(!isWasmInitialized) {
10334 throw new Error("initializeWasm() must be awaited first!");
10336 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10337 return nativeResponseValue;
10339 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10341 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
10342 if(!isWasmInitialized) {
10343 throw new Error("initializeWasm() must be awaited first!");
10345 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
10346 return nativeResponseValue;
10348 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
10350 export function CVec_PaymentPreimageZ_free(_res: number): void {
10351 if(!isWasmInitialized) {
10352 throw new Error("initializeWasm() must be awaited first!");
10354 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
10355 // debug statements here
10357 // uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10359 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: bigint): bigint {
10360 if(!isWasmInitialized) {
10361 throw new Error("initializeWasm() must be awaited first!");
10363 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10364 return nativeResponseValue;
10366 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
10368 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: bigint): bigint {
10369 if(!isWasmInitialized) {
10370 throw new Error("initializeWasm() must be awaited first!");
10372 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
10373 return nativeResponseValue;
10375 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
10377 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): bigint {
10378 if(!isWasmInitialized) {
10379 throw new Error("initializeWasm() must be awaited first!");
10381 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
10382 return nativeResponseValue;
10384 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
10386 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: bigint): void {
10387 if(!isWasmInitialized) {
10388 throw new Error("initializeWasm() must be awaited first!");
10390 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
10391 // debug statements here
10393 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
10395 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: bigint): bigint {
10396 if(!isWasmInitialized) {
10397 throw new Error("initializeWasm() must be awaited first!");
10399 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
10400 return nativeResponseValue;
10402 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
10404 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): bigint {
10405 if(!isWasmInitialized) {
10406 throw new Error("initializeWasm() must be awaited first!");
10408 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
10409 return nativeResponseValue;
10411 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
10413 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: bigint): boolean {
10414 if(!isWasmInitialized) {
10415 throw new Error("initializeWasm() must be awaited first!");
10417 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
10418 return nativeResponseValue;
10420 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
10422 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: bigint): void {
10423 if(!isWasmInitialized) {
10424 throw new Error("initializeWasm() must be awaited first!");
10426 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
10427 // debug statements here
10429 // uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
10431 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
10432 if(!isWasmInitialized) {
10433 throw new Error("initializeWasm() must be awaited first!");
10435 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
10436 return nativeResponseValue;
10438 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
10440 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: bigint): bigint {
10441 if(!isWasmInitialized) {
10442 throw new Error("initializeWasm() must be awaited first!");
10444 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
10445 return nativeResponseValue;
10447 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
10449 export function CResult_SignatureNoneZ_ok(o: number): bigint {
10450 if(!isWasmInitialized) {
10451 throw new Error("initializeWasm() must be awaited first!");
10453 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
10454 return nativeResponseValue;
10456 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
10458 export function CResult_SignatureNoneZ_err(): bigint {
10459 if(!isWasmInitialized) {
10460 throw new Error("initializeWasm() must be awaited first!");
10462 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
10463 return nativeResponseValue;
10465 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
10467 export function CResult_SignatureNoneZ_is_ok(o: bigint): boolean {
10468 if(!isWasmInitialized) {
10469 throw new Error("initializeWasm() must be awaited first!");
10471 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
10472 return nativeResponseValue;
10474 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
10476 export function CResult_SignatureNoneZ_free(_res: bigint): void {
10477 if(!isWasmInitialized) {
10478 throw new Error("initializeWasm() must be awaited first!");
10480 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
10481 // debug statements here
10483 // uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
10485 export function CResult_SignatureNoneZ_clone_ptr(arg: bigint): bigint {
10486 if(!isWasmInitialized) {
10487 throw new Error("initializeWasm() must be awaited first!");
10489 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
10490 return nativeResponseValue;
10492 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
10494 export function CResult_SignatureNoneZ_clone(orig: bigint): bigint {
10495 if(!isWasmInitialized) {
10496 throw new Error("initializeWasm() must be awaited first!");
10498 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
10499 return nativeResponseValue;
10501 // uint64_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
10503 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: bigint): bigint {
10504 if(!isWasmInitialized) {
10505 throw new Error("initializeWasm() must be awaited first!");
10507 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
10508 return nativeResponseValue;
10510 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
10512 export function C2Tuple_SignatureSignatureZ_clone(orig: bigint): bigint {
10513 if(!isWasmInitialized) {
10514 throw new Error("initializeWasm() must be awaited first!");
10516 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
10517 return nativeResponseValue;
10519 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
10521 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): bigint {
10522 if(!isWasmInitialized) {
10523 throw new Error("initializeWasm() must be awaited first!");
10525 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
10526 return nativeResponseValue;
10528 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
10530 export function C2Tuple_SignatureSignatureZ_free(_res: bigint): void {
10531 if(!isWasmInitialized) {
10532 throw new Error("initializeWasm() must be awaited first!");
10534 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
10535 // debug statements here
10537 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
10539 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: bigint): bigint {
10540 if(!isWasmInitialized) {
10541 throw new Error("initializeWasm() must be awaited first!");
10543 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
10544 return nativeResponseValue;
10546 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
10548 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): bigint {
10549 if(!isWasmInitialized) {
10550 throw new Error("initializeWasm() must be awaited first!");
10552 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
10553 return nativeResponseValue;
10555 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
10557 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: bigint): boolean {
10558 if(!isWasmInitialized) {
10559 throw new Error("initializeWasm() must be awaited first!");
10561 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
10562 return nativeResponseValue;
10564 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10566 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: bigint): void {
10567 if(!isWasmInitialized) {
10568 throw new Error("initializeWasm() must be awaited first!");
10570 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10571 // debug statements here
10573 // uint64_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10575 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: bigint): bigint {
10576 if(!isWasmInitialized) {
10577 throw new Error("initializeWasm() must be awaited first!");
10579 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10580 return nativeResponseValue;
10582 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10584 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: bigint): bigint {
10585 if(!isWasmInitialized) {
10586 throw new Error("initializeWasm() must be awaited first!");
10588 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10589 return nativeResponseValue;
10591 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10593 export function CResult_SecretKeyNoneZ_ok(o: number): bigint {
10594 if(!isWasmInitialized) {
10595 throw new Error("initializeWasm() must be awaited first!");
10597 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10598 return nativeResponseValue;
10600 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10602 export function CResult_SecretKeyNoneZ_err(): bigint {
10603 if(!isWasmInitialized) {
10604 throw new Error("initializeWasm() must be awaited first!");
10606 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10607 return nativeResponseValue;
10609 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10611 export function CResult_SecretKeyNoneZ_is_ok(o: bigint): boolean {
10612 if(!isWasmInitialized) {
10613 throw new Error("initializeWasm() must be awaited first!");
10615 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10616 return nativeResponseValue;
10618 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10620 export function CResult_SecretKeyNoneZ_free(_res: bigint): void {
10621 if(!isWasmInitialized) {
10622 throw new Error("initializeWasm() must be awaited first!");
10624 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10625 // debug statements here
10627 // uint64_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10629 export function CResult_SecretKeyNoneZ_clone_ptr(arg: bigint): bigint {
10630 if(!isWasmInitialized) {
10631 throw new Error("initializeWasm() must be awaited first!");
10633 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10634 return nativeResponseValue;
10636 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10638 export function CResult_SecretKeyNoneZ_clone(orig: bigint): bigint {
10639 if(!isWasmInitialized) {
10640 throw new Error("initializeWasm() must be awaited first!");
10642 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10643 return nativeResponseValue;
10645 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10647 export function CResult_SignDecodeErrorZ_ok(o: bigint): bigint {
10648 if(!isWasmInitialized) {
10649 throw new Error("initializeWasm() must be awaited first!");
10651 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10652 return nativeResponseValue;
10654 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10656 export function CResult_SignDecodeErrorZ_err(e: bigint): bigint {
10657 if(!isWasmInitialized) {
10658 throw new Error("initializeWasm() must be awaited first!");
10660 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10661 return nativeResponseValue;
10663 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10665 export function CResult_SignDecodeErrorZ_is_ok(o: bigint): boolean {
10666 if(!isWasmInitialized) {
10667 throw new Error("initializeWasm() must be awaited first!");
10669 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10670 return nativeResponseValue;
10672 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10674 export function CResult_SignDecodeErrorZ_free(_res: bigint): void {
10675 if(!isWasmInitialized) {
10676 throw new Error("initializeWasm() must be awaited first!");
10678 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10679 // debug statements here
10681 // uint64_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10683 export function CResult_SignDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10684 if(!isWasmInitialized) {
10685 throw new Error("initializeWasm() must be awaited first!");
10687 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10688 return nativeResponseValue;
10690 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10692 export function CResult_SignDecodeErrorZ_clone(orig: bigint): bigint {
10693 if(!isWasmInitialized) {
10694 throw new Error("initializeWasm() must be awaited first!");
10696 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10697 return nativeResponseValue;
10699 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10701 export function CVec_u5Z_free(_res: number): void {
10702 if(!isWasmInitialized) {
10703 throw new Error("initializeWasm() must be awaited first!");
10705 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10706 // debug statements here
10708 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10710 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
10711 if(!isWasmInitialized) {
10712 throw new Error("initializeWasm() must be awaited first!");
10714 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10715 return nativeResponseValue;
10717 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10719 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
10720 if(!isWasmInitialized) {
10721 throw new Error("initializeWasm() must be awaited first!");
10723 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10724 return nativeResponseValue;
10726 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10728 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
10729 if(!isWasmInitialized) {
10730 throw new Error("initializeWasm() must be awaited first!");
10732 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10733 return nativeResponseValue;
10735 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10737 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
10738 if(!isWasmInitialized) {
10739 throw new Error("initializeWasm() must be awaited first!");
10741 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10742 // debug statements here
10744 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10746 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
10747 if(!isWasmInitialized) {
10748 throw new Error("initializeWasm() must be awaited first!");
10750 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10751 return nativeResponseValue;
10753 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10755 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
10756 if(!isWasmInitialized) {
10757 throw new Error("initializeWasm() must be awaited first!");
10759 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10760 return nativeResponseValue;
10762 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10764 export function CVec_u8Z_free(_res: number): void {
10765 if(!isWasmInitialized) {
10766 throw new Error("initializeWasm() must be awaited first!");
10768 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10769 // debug statements here
10771 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10773 export function CVec_CVec_u8ZZ_free(_res: number): void {
10774 if(!isWasmInitialized) {
10775 throw new Error("initializeWasm() must be awaited first!");
10777 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10778 // debug statements here
10780 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10782 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
10783 if(!isWasmInitialized) {
10784 throw new Error("initializeWasm() must be awaited first!");
10786 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10787 return nativeResponseValue;
10789 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10791 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
10792 if(!isWasmInitialized) {
10793 throw new Error("initializeWasm() must be awaited first!");
10795 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10796 return nativeResponseValue;
10798 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10800 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
10801 if(!isWasmInitialized) {
10802 throw new Error("initializeWasm() must be awaited first!");
10804 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10805 return nativeResponseValue;
10807 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10809 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
10810 if(!isWasmInitialized) {
10811 throw new Error("initializeWasm() must be awaited first!");
10813 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10814 // debug statements here
10816 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10818 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
10819 if(!isWasmInitialized) {
10820 throw new Error("initializeWasm() must be awaited first!");
10822 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10823 return nativeResponseValue;
10825 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10827 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
10828 if(!isWasmInitialized) {
10829 throw new Error("initializeWasm() must be awaited first!");
10831 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10832 return nativeResponseValue;
10834 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10836 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
10837 if(!isWasmInitialized) {
10838 throw new Error("initializeWasm() must be awaited first!");
10840 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10841 return nativeResponseValue;
10843 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10845 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
10846 if(!isWasmInitialized) {
10847 throw new Error("initializeWasm() must be awaited first!");
10849 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10850 return nativeResponseValue;
10852 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10854 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
10855 if(!isWasmInitialized) {
10856 throw new Error("initializeWasm() must be awaited first!");
10858 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10859 return nativeResponseValue;
10861 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10863 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
10864 if(!isWasmInitialized) {
10865 throw new Error("initializeWasm() must be awaited first!");
10867 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10868 // debug statements here
10870 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10872 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
10873 if(!isWasmInitialized) {
10874 throw new Error("initializeWasm() must be awaited first!");
10876 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10877 return nativeResponseValue;
10879 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10881 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
10882 if(!isWasmInitialized) {
10883 throw new Error("initializeWasm() must be awaited first!");
10885 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10886 return nativeResponseValue;
10888 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10890 export function CVec_TxOutZ_free(_res: number): void {
10891 if(!isWasmInitialized) {
10892 throw new Error("initializeWasm() must be awaited first!");
10894 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10895 // debug statements here
10897 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10899 export function CResult_TransactionNoneZ_ok(o: number): bigint {
10900 if(!isWasmInitialized) {
10901 throw new Error("initializeWasm() must be awaited first!");
10903 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10904 return nativeResponseValue;
10906 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10908 export function CResult_TransactionNoneZ_err(): bigint {
10909 if(!isWasmInitialized) {
10910 throw new Error("initializeWasm() must be awaited first!");
10912 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10913 return nativeResponseValue;
10915 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10917 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
10918 if(!isWasmInitialized) {
10919 throw new Error("initializeWasm() must be awaited first!");
10921 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10922 return nativeResponseValue;
10924 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10926 export function CResult_TransactionNoneZ_free(_res: bigint): void {
10927 if(!isWasmInitialized) {
10928 throw new Error("initializeWasm() must be awaited first!");
10930 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10931 // debug statements here
10933 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10935 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
10936 if(!isWasmInitialized) {
10937 throw new Error("initializeWasm() must be awaited first!");
10939 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10940 return nativeResponseValue;
10942 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10944 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
10945 if(!isWasmInitialized) {
10946 throw new Error("initializeWasm() must be awaited first!");
10948 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10949 return nativeResponseValue;
10951 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10953 export function COption_u16Z_some(o: number): bigint {
10954 if(!isWasmInitialized) {
10955 throw new Error("initializeWasm() must be awaited first!");
10957 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10958 return nativeResponseValue;
10960 // struct LDKCOption_u16Z COption_u16Z_none(void);
10962 export function COption_u16Z_none(): bigint {
10963 if(!isWasmInitialized) {
10964 throw new Error("initializeWasm() must be awaited first!");
10966 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10967 return nativeResponseValue;
10969 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10971 export function COption_u16Z_free(_res: bigint): void {
10972 if(!isWasmInitialized) {
10973 throw new Error("initializeWasm() must be awaited first!");
10975 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10976 // debug statements here
10978 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10980 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
10981 if(!isWasmInitialized) {
10982 throw new Error("initializeWasm() must be awaited first!");
10984 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10985 return nativeResponseValue;
10987 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10989 export function COption_u16Z_clone(orig: bigint): bigint {
10990 if(!isWasmInitialized) {
10991 throw new Error("initializeWasm() must be awaited first!");
10993 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10994 return nativeResponseValue;
10996 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10998 export function CResult_NoneAPIErrorZ_ok(): bigint {
10999 if(!isWasmInitialized) {
11000 throw new Error("initializeWasm() must be awaited first!");
11002 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11003 return nativeResponseValue;
11005 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11007 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
11008 if(!isWasmInitialized) {
11009 throw new Error("initializeWasm() must be awaited first!");
11011 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11012 return nativeResponseValue;
11014 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11016 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
11017 if(!isWasmInitialized) {
11018 throw new Error("initializeWasm() must be awaited first!");
11020 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11021 return nativeResponseValue;
11023 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11025 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
11026 if(!isWasmInitialized) {
11027 throw new Error("initializeWasm() must be awaited first!");
11029 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11030 // debug statements here
11032 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11034 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
11035 if(!isWasmInitialized) {
11036 throw new Error("initializeWasm() must be awaited first!");
11038 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11039 return nativeResponseValue;
11041 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11043 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
11044 if(!isWasmInitialized) {
11045 throw new Error("initializeWasm() must be awaited first!");
11047 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11048 return nativeResponseValue;
11050 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11052 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11053 if(!isWasmInitialized) {
11054 throw new Error("initializeWasm() must be awaited first!");
11056 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11057 // debug statements here
11059 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11061 export function CVec_APIErrorZ_free(_res: number): void {
11062 if(!isWasmInitialized) {
11063 throw new Error("initializeWasm() must be awaited first!");
11065 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11066 // debug statements here
11068 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11070 export function CResult__u832APIErrorZ_ok(o: number): bigint {
11071 if(!isWasmInitialized) {
11072 throw new Error("initializeWasm() must be awaited first!");
11074 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11075 return nativeResponseValue;
11077 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11079 export function CResult__u832APIErrorZ_err(e: bigint): bigint {
11080 if(!isWasmInitialized) {
11081 throw new Error("initializeWasm() must be awaited first!");
11083 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11084 return nativeResponseValue;
11086 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11088 export function CResult__u832APIErrorZ_is_ok(o: bigint): boolean {
11089 if(!isWasmInitialized) {
11090 throw new Error("initializeWasm() must be awaited first!");
11092 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11093 return nativeResponseValue;
11095 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11097 export function CResult__u832APIErrorZ_free(_res: bigint): void {
11098 if(!isWasmInitialized) {
11099 throw new Error("initializeWasm() must be awaited first!");
11101 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11102 // debug statements here
11104 // uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11106 export function CResult__u832APIErrorZ_clone_ptr(arg: bigint): bigint {
11107 if(!isWasmInitialized) {
11108 throw new Error("initializeWasm() must be awaited first!");
11110 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11111 return nativeResponseValue;
11113 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11115 export function CResult__u832APIErrorZ_clone(orig: bigint): bigint {
11116 if(!isWasmInitialized) {
11117 throw new Error("initializeWasm() must be awaited first!");
11119 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
11120 return nativeResponseValue;
11122 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
11124 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): bigint {
11125 if(!isWasmInitialized) {
11126 throw new Error("initializeWasm() must be awaited first!");
11128 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
11129 return nativeResponseValue;
11131 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11133 export function CResult_PaymentIdPaymentSendFailureZ_err(e: bigint): bigint {
11134 if(!isWasmInitialized) {
11135 throw new Error("initializeWasm() must be awaited first!");
11137 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
11138 return nativeResponseValue;
11140 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
11142 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: bigint): boolean {
11143 if(!isWasmInitialized) {
11144 throw new Error("initializeWasm() must be awaited first!");
11146 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
11147 return nativeResponseValue;
11149 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
11151 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: bigint): void {
11152 if(!isWasmInitialized) {
11153 throw new Error("initializeWasm() must be awaited first!");
11155 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
11156 // debug statements here
11158 // uint64_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
11160 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
11161 if(!isWasmInitialized) {
11162 throw new Error("initializeWasm() must be awaited first!");
11164 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
11165 return nativeResponseValue;
11167 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
11169 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: bigint): bigint {
11170 if(!isWasmInitialized) {
11171 throw new Error("initializeWasm() must be awaited first!");
11173 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
11174 return nativeResponseValue;
11176 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
11178 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
11179 if(!isWasmInitialized) {
11180 throw new Error("initializeWasm() must be awaited first!");
11182 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
11183 return nativeResponseValue;
11185 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11187 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
11188 if(!isWasmInitialized) {
11189 throw new Error("initializeWasm() must be awaited first!");
11191 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
11192 return nativeResponseValue;
11194 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
11196 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
11197 if(!isWasmInitialized) {
11198 throw new Error("initializeWasm() must be awaited first!");
11200 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
11201 return nativeResponseValue;
11203 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
11205 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
11206 if(!isWasmInitialized) {
11207 throw new Error("initializeWasm() must be awaited first!");
11209 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
11210 // debug statements here
11212 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
11214 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
11215 if(!isWasmInitialized) {
11216 throw new Error("initializeWasm() must be awaited first!");
11218 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
11219 return nativeResponseValue;
11221 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
11223 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
11224 if(!isWasmInitialized) {
11225 throw new Error("initializeWasm() must be awaited first!");
11227 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
11228 return nativeResponseValue;
11230 // uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
11232 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: bigint): bigint {
11233 if(!isWasmInitialized) {
11234 throw new Error("initializeWasm() must be awaited first!");
11236 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
11237 return nativeResponseValue;
11239 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
11241 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: bigint): bigint {
11242 if(!isWasmInitialized) {
11243 throw new Error("initializeWasm() must be awaited first!");
11245 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
11246 return nativeResponseValue;
11248 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11250 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): bigint {
11251 if(!isWasmInitialized) {
11252 throw new Error("initializeWasm() must be awaited first!");
11254 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
11255 return nativeResponseValue;
11257 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
11259 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: bigint): void {
11260 if(!isWasmInitialized) {
11261 throw new Error("initializeWasm() must be awaited first!");
11263 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
11264 // debug statements here
11266 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
11268 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: bigint): bigint {
11269 if(!isWasmInitialized) {
11270 throw new Error("initializeWasm() must be awaited first!");
11272 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
11273 return nativeResponseValue;
11275 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11277 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: bigint): bigint {
11278 if(!isWasmInitialized) {
11279 throw new Error("initializeWasm() must be awaited first!");
11281 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
11282 return nativeResponseValue;
11284 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
11286 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: bigint): boolean {
11287 if(!isWasmInitialized) {
11288 throw new Error("initializeWasm() must be awaited first!");
11290 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
11291 return nativeResponseValue;
11293 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
11295 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: bigint): void {
11296 if(!isWasmInitialized) {
11297 throw new Error("initializeWasm() must be awaited first!");
11299 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
11300 // debug statements here
11302 // uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
11304 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
11305 if(!isWasmInitialized) {
11306 throw new Error("initializeWasm() must be awaited first!");
11308 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
11309 return nativeResponseValue;
11311 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
11313 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: bigint): bigint {
11314 if(!isWasmInitialized) {
11315 throw new Error("initializeWasm() must be awaited first!");
11317 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
11318 return nativeResponseValue;
11320 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
11322 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
11323 if(!isWasmInitialized) {
11324 throw new Error("initializeWasm() must be awaited first!");
11326 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
11327 // debug statements here
11329 // uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
11331 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: bigint): bigint {
11332 if(!isWasmInitialized) {
11333 throw new Error("initializeWasm() must be awaited first!");
11335 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
11336 return nativeResponseValue;
11338 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
11340 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: bigint): bigint {
11341 if(!isWasmInitialized) {
11342 throw new Error("initializeWasm() must be awaited first!");
11344 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
11345 return nativeResponseValue;
11347 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11349 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): bigint {
11350 if(!isWasmInitialized) {
11351 throw new Error("initializeWasm() must be awaited first!");
11353 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
11354 return nativeResponseValue;
11356 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11358 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: bigint): void {
11359 if(!isWasmInitialized) {
11360 throw new Error("initializeWasm() must be awaited first!");
11362 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11363 // debug statements here
11365 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11367 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: bigint): bigint {
11368 if(!isWasmInitialized) {
11369 throw new Error("initializeWasm() must be awaited first!");
11371 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11372 return nativeResponseValue;
11374 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11376 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): bigint {
11377 if(!isWasmInitialized) {
11378 throw new Error("initializeWasm() must be awaited first!");
11380 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11381 return nativeResponseValue;
11383 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11385 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: bigint): boolean {
11386 if(!isWasmInitialized) {
11387 throw new Error("initializeWasm() must be awaited first!");
11389 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11390 return nativeResponseValue;
11392 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11394 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: bigint): void {
11395 if(!isWasmInitialized) {
11396 throw new Error("initializeWasm() must be awaited first!");
11398 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11399 // debug statements here
11401 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11403 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: bigint): bigint {
11404 if(!isWasmInitialized) {
11405 throw new Error("initializeWasm() must be awaited first!");
11407 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11408 return nativeResponseValue;
11410 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11412 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: bigint): bigint {
11413 if(!isWasmInitialized) {
11414 throw new Error("initializeWasm() must be awaited first!");
11416 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11417 return nativeResponseValue;
11419 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11421 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: bigint): bigint {
11422 if(!isWasmInitialized) {
11423 throw new Error("initializeWasm() must be awaited first!");
11425 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11426 return nativeResponseValue;
11428 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11430 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: bigint): bigint {
11431 if(!isWasmInitialized) {
11432 throw new Error("initializeWasm() must be awaited first!");
11434 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11435 return nativeResponseValue;
11437 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11439 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: bigint): boolean {
11440 if(!isWasmInitialized) {
11441 throw new Error("initializeWasm() must be awaited first!");
11443 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11444 return nativeResponseValue;
11446 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
11448 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: bigint): void {
11449 if(!isWasmInitialized) {
11450 throw new Error("initializeWasm() must be awaited first!");
11452 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
11453 // debug statements here
11455 // uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
11457 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: bigint): bigint {
11458 if(!isWasmInitialized) {
11459 throw new Error("initializeWasm() must be awaited first!");
11461 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
11462 return nativeResponseValue;
11464 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
11466 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: bigint): bigint {
11467 if(!isWasmInitialized) {
11468 throw new Error("initializeWasm() must be awaited first!");
11470 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
11471 return nativeResponseValue;
11473 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11475 export function CResult_PaymentSecretNoneZ_ok(o: number): bigint {
11476 if(!isWasmInitialized) {
11477 throw new Error("initializeWasm() must be awaited first!");
11479 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
11480 return nativeResponseValue;
11482 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
11484 export function CResult_PaymentSecretNoneZ_err(): bigint {
11485 if(!isWasmInitialized) {
11486 throw new Error("initializeWasm() must be awaited first!");
11488 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
11489 return nativeResponseValue;
11491 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
11493 export function CResult_PaymentSecretNoneZ_is_ok(o: bigint): boolean {
11494 if(!isWasmInitialized) {
11495 throw new Error("initializeWasm() must be awaited first!");
11497 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
11498 return nativeResponseValue;
11500 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
11502 export function CResult_PaymentSecretNoneZ_free(_res: bigint): void {
11503 if(!isWasmInitialized) {
11504 throw new Error("initializeWasm() must be awaited first!");
11506 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
11507 // debug statements here
11509 // uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
11511 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: bigint): bigint {
11512 if(!isWasmInitialized) {
11513 throw new Error("initializeWasm() must be awaited first!");
11515 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
11516 return nativeResponseValue;
11518 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
11520 export function CResult_PaymentSecretNoneZ_clone(orig: bigint): bigint {
11521 if(!isWasmInitialized) {
11522 throw new Error("initializeWasm() must be awaited first!");
11524 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
11525 return nativeResponseValue;
11527 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11529 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): bigint {
11530 if(!isWasmInitialized) {
11531 throw new Error("initializeWasm() must be awaited first!");
11533 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
11534 return nativeResponseValue;
11536 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
11538 export function CResult_PaymentSecretAPIErrorZ_err(e: bigint): bigint {
11539 if(!isWasmInitialized) {
11540 throw new Error("initializeWasm() must be awaited first!");
11542 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
11543 return nativeResponseValue;
11545 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
11547 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: bigint): boolean {
11548 if(!isWasmInitialized) {
11549 throw new Error("initializeWasm() must be awaited first!");
11551 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
11552 return nativeResponseValue;
11554 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
11556 export function CResult_PaymentSecretAPIErrorZ_free(_res: bigint): void {
11557 if(!isWasmInitialized) {
11558 throw new Error("initializeWasm() must be awaited first!");
11560 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
11561 // debug statements here
11563 // uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
11565 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: bigint): bigint {
11566 if(!isWasmInitialized) {
11567 throw new Error("initializeWasm() must be awaited first!");
11569 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
11570 return nativeResponseValue;
11572 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11574 export function CResult_PaymentSecretAPIErrorZ_clone(orig: bigint): bigint {
11575 if(!isWasmInitialized) {
11576 throw new Error("initializeWasm() must be awaited first!");
11578 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11579 return nativeResponseValue;
11581 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11583 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): bigint {
11584 if(!isWasmInitialized) {
11585 throw new Error("initializeWasm() must be awaited first!");
11587 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11588 return nativeResponseValue;
11590 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11592 export function CResult_PaymentPreimageAPIErrorZ_err(e: bigint): bigint {
11593 if(!isWasmInitialized) {
11594 throw new Error("initializeWasm() must be awaited first!");
11596 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11597 return nativeResponseValue;
11599 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11601 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: bigint): boolean {
11602 if(!isWasmInitialized) {
11603 throw new Error("initializeWasm() must be awaited first!");
11605 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11606 return nativeResponseValue;
11608 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11610 export function CResult_PaymentPreimageAPIErrorZ_free(_res: bigint): void {
11611 if(!isWasmInitialized) {
11612 throw new Error("initializeWasm() must be awaited first!");
11614 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11615 // debug statements here
11617 // uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11619 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: bigint): bigint {
11620 if(!isWasmInitialized) {
11621 throw new Error("initializeWasm() must be awaited first!");
11623 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11624 return nativeResponseValue;
11626 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11628 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: bigint): bigint {
11629 if(!isWasmInitialized) {
11630 throw new Error("initializeWasm() must be awaited first!");
11632 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11633 return nativeResponseValue;
11635 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11637 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
11638 if(!isWasmInitialized) {
11639 throw new Error("initializeWasm() must be awaited first!");
11641 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11642 return nativeResponseValue;
11644 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11646 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
11647 if(!isWasmInitialized) {
11648 throw new Error("initializeWasm() must be awaited first!");
11650 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11651 return nativeResponseValue;
11653 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11655 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11656 if(!isWasmInitialized) {
11657 throw new Error("initializeWasm() must be awaited first!");
11659 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11660 return nativeResponseValue;
11662 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11664 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
11665 if(!isWasmInitialized) {
11666 throw new Error("initializeWasm() must be awaited first!");
11668 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11669 // debug statements here
11671 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11673 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11674 if(!isWasmInitialized) {
11675 throw new Error("initializeWasm() must be awaited first!");
11677 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11678 return nativeResponseValue;
11680 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11682 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
11683 if(!isWasmInitialized) {
11684 throw new Error("initializeWasm() must be awaited first!");
11686 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11687 return nativeResponseValue;
11689 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11691 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
11692 if(!isWasmInitialized) {
11693 throw new Error("initializeWasm() must be awaited first!");
11695 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11696 return nativeResponseValue;
11698 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11700 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
11701 if(!isWasmInitialized) {
11702 throw new Error("initializeWasm() must be awaited first!");
11704 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11705 return nativeResponseValue;
11707 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11709 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
11710 if(!isWasmInitialized) {
11711 throw new Error("initializeWasm() must be awaited first!");
11713 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11714 return nativeResponseValue;
11716 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11718 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
11719 if(!isWasmInitialized) {
11720 throw new Error("initializeWasm() must be awaited first!");
11722 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11723 // debug statements here
11725 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11727 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11728 if(!isWasmInitialized) {
11729 throw new Error("initializeWasm() must be awaited first!");
11731 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11732 return nativeResponseValue;
11734 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11736 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
11737 if(!isWasmInitialized) {
11738 throw new Error("initializeWasm() must be awaited first!");
11740 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11741 return nativeResponseValue;
11743 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11745 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
11746 if(!isWasmInitialized) {
11747 throw new Error("initializeWasm() must be awaited first!");
11749 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11750 return nativeResponseValue;
11752 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11754 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
11755 if(!isWasmInitialized) {
11756 throw new Error("initializeWasm() must be awaited first!");
11758 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11759 return nativeResponseValue;
11761 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11763 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
11764 if(!isWasmInitialized) {
11765 throw new Error("initializeWasm() must be awaited first!");
11767 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11768 return nativeResponseValue;
11770 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11772 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
11773 if(!isWasmInitialized) {
11774 throw new Error("initializeWasm() must be awaited first!");
11776 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11777 // debug statements here
11779 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11781 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11782 if(!isWasmInitialized) {
11783 throw new Error("initializeWasm() must be awaited first!");
11785 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11786 return nativeResponseValue;
11788 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11790 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
11791 if(!isWasmInitialized) {
11792 throw new Error("initializeWasm() must be awaited first!");
11794 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11795 return nativeResponseValue;
11797 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11799 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
11800 if(!isWasmInitialized) {
11801 throw new Error("initializeWasm() must be awaited first!");
11803 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11804 return nativeResponseValue;
11806 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11808 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
11809 if(!isWasmInitialized) {
11810 throw new Error("initializeWasm() must be awaited first!");
11812 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11813 return nativeResponseValue;
11815 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11817 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
11818 if(!isWasmInitialized) {
11819 throw new Error("initializeWasm() must be awaited first!");
11821 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11822 return nativeResponseValue;
11824 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11826 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
11827 if(!isWasmInitialized) {
11828 throw new Error("initializeWasm() must be awaited first!");
11830 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11831 // debug statements here
11833 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11835 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11836 if(!isWasmInitialized) {
11837 throw new Error("initializeWasm() must be awaited first!");
11839 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11840 return nativeResponseValue;
11842 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11844 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
11845 if(!isWasmInitialized) {
11846 throw new Error("initializeWasm() must be awaited first!");
11848 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11849 return nativeResponseValue;
11851 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11853 export function CVec_ChannelMonitorZ_free(_res: number): void {
11854 if(!isWasmInitialized) {
11855 throw new Error("initializeWasm() must be awaited first!");
11857 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11858 // debug statements here
11860 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11862 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: bigint): bigint {
11863 if(!isWasmInitialized) {
11864 throw new Error("initializeWasm() must be awaited first!");
11866 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11867 return nativeResponseValue;
11869 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11871 export function C2Tuple_BlockHashChannelManagerZ_free(_res: bigint): void {
11872 if(!isWasmInitialized) {
11873 throw new Error("initializeWasm() must be awaited first!");
11875 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11876 // debug statements here
11878 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11880 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
11881 if(!isWasmInitialized) {
11882 throw new Error("initializeWasm() must be awaited first!");
11884 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11885 return nativeResponseValue;
11887 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11889 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
11890 if(!isWasmInitialized) {
11891 throw new Error("initializeWasm() must be awaited first!");
11893 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11894 return nativeResponseValue;
11896 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11898 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
11899 if(!isWasmInitialized) {
11900 throw new Error("initializeWasm() must be awaited first!");
11902 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11903 return nativeResponseValue;
11905 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11907 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: bigint): void {
11908 if(!isWasmInitialized) {
11909 throw new Error("initializeWasm() must be awaited first!");
11911 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11912 // debug statements here
11914 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11916 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
11917 if(!isWasmInitialized) {
11918 throw new Error("initializeWasm() must be awaited first!");
11920 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11921 return nativeResponseValue;
11923 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11925 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
11926 if(!isWasmInitialized) {
11927 throw new Error("initializeWasm() must be awaited first!");
11929 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11930 return nativeResponseValue;
11932 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11934 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
11935 if(!isWasmInitialized) {
11936 throw new Error("initializeWasm() must be awaited first!");
11938 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11939 return nativeResponseValue;
11941 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11943 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
11944 if(!isWasmInitialized) {
11945 throw new Error("initializeWasm() must be awaited first!");
11947 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11948 // debug statements here
11950 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11952 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11953 if(!isWasmInitialized) {
11954 throw new Error("initializeWasm() must be awaited first!");
11956 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11957 return nativeResponseValue;
11959 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11961 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
11962 if(!isWasmInitialized) {
11963 throw new Error("initializeWasm() must be awaited first!");
11965 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11966 return nativeResponseValue;
11968 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11970 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
11971 if(!isWasmInitialized) {
11972 throw new Error("initializeWasm() must be awaited first!");
11974 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11975 return nativeResponseValue;
11977 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11979 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
11980 if(!isWasmInitialized) {
11981 throw new Error("initializeWasm() must be awaited first!");
11983 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11984 return nativeResponseValue;
11986 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11988 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
11989 if(!isWasmInitialized) {
11990 throw new Error("initializeWasm() must be awaited first!");
11992 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11993 return nativeResponseValue;
11995 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11997 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
11998 if(!isWasmInitialized) {
11999 throw new Error("initializeWasm() must be awaited first!");
12001 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
12002 // debug statements here
12004 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
12006 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12007 if(!isWasmInitialized) {
12008 throw new Error("initializeWasm() must be awaited first!");
12010 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
12011 return nativeResponseValue;
12013 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
12015 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
12016 if(!isWasmInitialized) {
12017 throw new Error("initializeWasm() must be awaited first!");
12019 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
12020 return nativeResponseValue;
12022 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
12024 export function COption_TypeZ_some(o: bigint): bigint {
12025 if(!isWasmInitialized) {
12026 throw new Error("initializeWasm() must be awaited first!");
12028 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
12029 return nativeResponseValue;
12031 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
12033 export function COption_TypeZ_none(): bigint {
12034 if(!isWasmInitialized) {
12035 throw new Error("initializeWasm() must be awaited first!");
12037 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
12038 return nativeResponseValue;
12040 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
12042 export function COption_TypeZ_free(_res: bigint): void {
12043 if(!isWasmInitialized) {
12044 throw new Error("initializeWasm() must be awaited first!");
12046 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
12047 // debug statements here
12049 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
12051 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
12052 if(!isWasmInitialized) {
12053 throw new Error("initializeWasm() must be awaited first!");
12055 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
12056 return nativeResponseValue;
12058 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
12060 export function COption_TypeZ_clone(orig: bigint): bigint {
12061 if(!isWasmInitialized) {
12062 throw new Error("initializeWasm() must be awaited first!");
12064 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
12065 return nativeResponseValue;
12067 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
12069 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
12070 if(!isWasmInitialized) {
12071 throw new Error("initializeWasm() must be awaited first!");
12073 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
12074 return nativeResponseValue;
12076 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
12078 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
12079 if(!isWasmInitialized) {
12080 throw new Error("initializeWasm() must be awaited first!");
12082 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
12083 return nativeResponseValue;
12085 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
12087 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
12088 if(!isWasmInitialized) {
12089 throw new Error("initializeWasm() must be awaited first!");
12091 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
12092 return nativeResponseValue;
12094 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
12096 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
12097 if(!isWasmInitialized) {
12098 throw new Error("initializeWasm() must be awaited first!");
12100 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
12101 // debug statements here
12103 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
12105 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12106 if(!isWasmInitialized) {
12107 throw new Error("initializeWasm() must be awaited first!");
12109 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
12110 return nativeResponseValue;
12112 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
12114 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
12115 if(!isWasmInitialized) {
12116 throw new Error("initializeWasm() must be awaited first!");
12118 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
12119 return nativeResponseValue;
12121 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
12123 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): bigint {
12124 if(!isWasmInitialized) {
12125 throw new Error("initializeWasm() must be awaited first!");
12127 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
12128 return nativeResponseValue;
12130 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
12132 export function CResult_PaymentIdPaymentErrorZ_err(e: bigint): bigint {
12133 if(!isWasmInitialized) {
12134 throw new Error("initializeWasm() must be awaited first!");
12136 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
12137 return nativeResponseValue;
12139 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
12141 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: bigint): boolean {
12142 if(!isWasmInitialized) {
12143 throw new Error("initializeWasm() must be awaited first!");
12145 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
12146 return nativeResponseValue;
12148 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
12150 export function CResult_PaymentIdPaymentErrorZ_free(_res: bigint): void {
12151 if(!isWasmInitialized) {
12152 throw new Error("initializeWasm() must be awaited first!");
12154 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
12155 // debug statements here
12157 // uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
12159 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: bigint): bigint {
12160 if(!isWasmInitialized) {
12161 throw new Error("initializeWasm() must be awaited first!");
12163 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
12164 return nativeResponseValue;
12166 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
12168 export function CResult_PaymentIdPaymentErrorZ_clone(orig: bigint): bigint {
12169 if(!isWasmInitialized) {
12170 throw new Error("initializeWasm() must be awaited first!");
12172 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
12173 return nativeResponseValue;
12175 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
12177 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): bigint {
12178 if(!isWasmInitialized) {
12179 throw new Error("initializeWasm() must be awaited first!");
12181 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
12182 return nativeResponseValue;
12184 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
12186 export function CResult_SiPrefixParseErrorZ_err(e: bigint): bigint {
12187 if(!isWasmInitialized) {
12188 throw new Error("initializeWasm() must be awaited first!");
12190 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
12191 return nativeResponseValue;
12193 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
12195 export function CResult_SiPrefixParseErrorZ_is_ok(o: bigint): boolean {
12196 if(!isWasmInitialized) {
12197 throw new Error("initializeWasm() must be awaited first!");
12199 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
12200 return nativeResponseValue;
12202 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
12204 export function CResult_SiPrefixParseErrorZ_free(_res: bigint): void {
12205 if(!isWasmInitialized) {
12206 throw new Error("initializeWasm() must be awaited first!");
12208 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
12209 // debug statements here
12211 // uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
12213 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: bigint): bigint {
12214 if(!isWasmInitialized) {
12215 throw new Error("initializeWasm() must be awaited first!");
12217 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
12218 return nativeResponseValue;
12220 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
12222 export function CResult_SiPrefixParseErrorZ_clone(orig: bigint): bigint {
12223 if(!isWasmInitialized) {
12224 throw new Error("initializeWasm() must be awaited first!");
12226 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
12227 return nativeResponseValue;
12229 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
12231 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
12232 if(!isWasmInitialized) {
12233 throw new Error("initializeWasm() must be awaited first!");
12235 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
12236 return nativeResponseValue;
12238 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
12240 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
12241 if(!isWasmInitialized) {
12242 throw new Error("initializeWasm() must be awaited first!");
12244 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
12245 return nativeResponseValue;
12247 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
12249 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
12250 if(!isWasmInitialized) {
12251 throw new Error("initializeWasm() must be awaited first!");
12253 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
12254 return nativeResponseValue;
12256 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
12258 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
12259 if(!isWasmInitialized) {
12260 throw new Error("initializeWasm() must be awaited first!");
12262 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
12263 // debug statements here
12265 // uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
12267 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
12268 if(!isWasmInitialized) {
12269 throw new Error("initializeWasm() must be awaited first!");
12271 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
12272 return nativeResponseValue;
12274 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
12276 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
12277 if(!isWasmInitialized) {
12278 throw new Error("initializeWasm() must be awaited first!");
12280 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
12281 return nativeResponseValue;
12283 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
12285 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: bigint): bigint {
12286 if(!isWasmInitialized) {
12287 throw new Error("initializeWasm() must be awaited first!");
12289 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
12290 return nativeResponseValue;
12292 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
12294 export function CResult_SignedRawInvoiceParseErrorZ_err(e: bigint): bigint {
12295 if(!isWasmInitialized) {
12296 throw new Error("initializeWasm() must be awaited first!");
12298 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
12299 return nativeResponseValue;
12301 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
12303 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: bigint): boolean {
12304 if(!isWasmInitialized) {
12305 throw new Error("initializeWasm() must be awaited first!");
12307 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
12308 return nativeResponseValue;
12310 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
12312 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: bigint): void {
12313 if(!isWasmInitialized) {
12314 throw new Error("initializeWasm() must be awaited first!");
12316 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
12317 // debug statements here
12319 // uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
12321 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: bigint): bigint {
12322 if(!isWasmInitialized) {
12323 throw new Error("initializeWasm() must be awaited first!");
12325 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
12326 return nativeResponseValue;
12328 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
12330 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: bigint): bigint {
12331 if(!isWasmInitialized) {
12332 throw new Error("initializeWasm() must be awaited first!");
12334 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
12335 return nativeResponseValue;
12337 // uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
12339 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
12340 if(!isWasmInitialized) {
12341 throw new Error("initializeWasm() must be awaited first!");
12343 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
12344 return nativeResponseValue;
12346 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
12348 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: bigint): bigint {
12349 if(!isWasmInitialized) {
12350 throw new Error("initializeWasm() must be awaited first!");
12352 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
12353 return nativeResponseValue;
12355 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
12357 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
12358 if(!isWasmInitialized) {
12359 throw new Error("initializeWasm() must be awaited first!");
12361 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
12362 return nativeResponseValue;
12364 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
12366 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: bigint): void {
12367 if(!isWasmInitialized) {
12368 throw new Error("initializeWasm() must be awaited first!");
12370 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
12371 // debug statements here
12373 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
12375 export function CResult_PayeePubKeyErrorZ_ok(o: bigint): bigint {
12376 if(!isWasmInitialized) {
12377 throw new Error("initializeWasm() must be awaited first!");
12379 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
12380 return nativeResponseValue;
12382 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
12384 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): bigint {
12385 if(!isWasmInitialized) {
12386 throw new Error("initializeWasm() must be awaited first!");
12388 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
12389 return nativeResponseValue;
12391 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
12393 export function CResult_PayeePubKeyErrorZ_is_ok(o: bigint): boolean {
12394 if(!isWasmInitialized) {
12395 throw new Error("initializeWasm() must be awaited first!");
12397 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
12398 return nativeResponseValue;
12400 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
12402 export function CResult_PayeePubKeyErrorZ_free(_res: bigint): void {
12403 if(!isWasmInitialized) {
12404 throw new Error("initializeWasm() must be awaited first!");
12406 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
12407 // debug statements here
12409 // uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
12411 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: bigint): bigint {
12412 if(!isWasmInitialized) {
12413 throw new Error("initializeWasm() must be awaited first!");
12415 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
12416 return nativeResponseValue;
12418 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
12420 export function CResult_PayeePubKeyErrorZ_clone(orig: bigint): bigint {
12421 if(!isWasmInitialized) {
12422 throw new Error("initializeWasm() must be awaited first!");
12424 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
12425 return nativeResponseValue;
12427 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
12429 export function CVec_PrivateRouteZ_free(_res: number): void {
12430 if(!isWasmInitialized) {
12431 throw new Error("initializeWasm() must be awaited first!");
12433 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
12434 // debug statements here
12436 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
12438 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
12439 if(!isWasmInitialized) {
12440 throw new Error("initializeWasm() must be awaited first!");
12442 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
12443 return nativeResponseValue;
12445 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
12447 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
12448 if(!isWasmInitialized) {
12449 throw new Error("initializeWasm() must be awaited first!");
12451 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
12452 return nativeResponseValue;
12454 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
12456 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
12457 if(!isWasmInitialized) {
12458 throw new Error("initializeWasm() must be awaited first!");
12460 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
12461 return nativeResponseValue;
12463 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
12465 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
12466 if(!isWasmInitialized) {
12467 throw new Error("initializeWasm() must be awaited first!");
12469 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
12470 // debug statements here
12472 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
12474 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
12475 if(!isWasmInitialized) {
12476 throw new Error("initializeWasm() must be awaited first!");
12478 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
12479 return nativeResponseValue;
12481 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
12483 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
12484 if(!isWasmInitialized) {
12485 throw new Error("initializeWasm() must be awaited first!");
12487 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
12488 return nativeResponseValue;
12490 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
12492 export function CResult_NoneSemanticErrorZ_ok(): bigint {
12493 if(!isWasmInitialized) {
12494 throw new Error("initializeWasm() must be awaited first!");
12496 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
12497 return nativeResponseValue;
12499 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
12501 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): bigint {
12502 if(!isWasmInitialized) {
12503 throw new Error("initializeWasm() must be awaited first!");
12505 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
12506 return nativeResponseValue;
12508 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
12510 export function CResult_NoneSemanticErrorZ_is_ok(o: bigint): boolean {
12511 if(!isWasmInitialized) {
12512 throw new Error("initializeWasm() must be awaited first!");
12514 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
12515 return nativeResponseValue;
12517 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
12519 export function CResult_NoneSemanticErrorZ_free(_res: bigint): void {
12520 if(!isWasmInitialized) {
12521 throw new Error("initializeWasm() must be awaited first!");
12523 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
12524 // debug statements here
12526 // uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
12528 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: bigint): bigint {
12529 if(!isWasmInitialized) {
12530 throw new Error("initializeWasm() must be awaited first!");
12532 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
12533 return nativeResponseValue;
12535 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
12537 export function CResult_NoneSemanticErrorZ_clone(orig: bigint): bigint {
12538 if(!isWasmInitialized) {
12539 throw new Error("initializeWasm() must be awaited first!");
12541 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
12542 return nativeResponseValue;
12544 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
12546 export function CResult_InvoiceSemanticErrorZ_ok(o: bigint): bigint {
12547 if(!isWasmInitialized) {
12548 throw new Error("initializeWasm() must be awaited first!");
12550 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
12551 return nativeResponseValue;
12553 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
12555 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): bigint {
12556 if(!isWasmInitialized) {
12557 throw new Error("initializeWasm() must be awaited first!");
12559 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
12560 return nativeResponseValue;
12562 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
12564 export function CResult_InvoiceSemanticErrorZ_is_ok(o: bigint): boolean {
12565 if(!isWasmInitialized) {
12566 throw new Error("initializeWasm() must be awaited first!");
12568 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
12569 return nativeResponseValue;
12571 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
12573 export function CResult_InvoiceSemanticErrorZ_free(_res: bigint): void {
12574 if(!isWasmInitialized) {
12575 throw new Error("initializeWasm() must be awaited first!");
12577 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12578 // debug statements here
12580 // uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12582 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: bigint): bigint {
12583 if(!isWasmInitialized) {
12584 throw new Error("initializeWasm() must be awaited first!");
12586 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12587 return nativeResponseValue;
12589 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12591 export function CResult_InvoiceSemanticErrorZ_clone(orig: bigint): bigint {
12592 if(!isWasmInitialized) {
12593 throw new Error("initializeWasm() must be awaited first!");
12595 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12596 return nativeResponseValue;
12598 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12600 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
12601 if(!isWasmInitialized) {
12602 throw new Error("initializeWasm() must be awaited first!");
12604 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12605 return nativeResponseValue;
12607 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12609 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
12610 if(!isWasmInitialized) {
12611 throw new Error("initializeWasm() must be awaited first!");
12613 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12614 return nativeResponseValue;
12616 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12618 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
12619 if(!isWasmInitialized) {
12620 throw new Error("initializeWasm() must be awaited first!");
12622 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12623 return nativeResponseValue;
12625 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12627 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
12628 if(!isWasmInitialized) {
12629 throw new Error("initializeWasm() must be awaited first!");
12631 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12632 // debug statements here
12634 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12636 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
12637 if(!isWasmInitialized) {
12638 throw new Error("initializeWasm() must be awaited first!");
12640 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12641 return nativeResponseValue;
12643 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12645 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
12646 if(!isWasmInitialized) {
12647 throw new Error("initializeWasm() must be awaited first!");
12649 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12650 return nativeResponseValue;
12652 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12654 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
12655 if(!isWasmInitialized) {
12656 throw new Error("initializeWasm() must be awaited first!");
12658 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12659 return nativeResponseValue;
12661 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12663 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
12664 if(!isWasmInitialized) {
12665 throw new Error("initializeWasm() must be awaited first!");
12667 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12668 return nativeResponseValue;
12670 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12672 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
12673 if(!isWasmInitialized) {
12674 throw new Error("initializeWasm() must be awaited first!");
12676 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12677 return nativeResponseValue;
12679 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12681 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
12682 if(!isWasmInitialized) {
12683 throw new Error("initializeWasm() must be awaited first!");
12685 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12686 // debug statements here
12688 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12690 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
12691 if(!isWasmInitialized) {
12692 throw new Error("initializeWasm() must be awaited first!");
12694 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12695 return nativeResponseValue;
12697 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12699 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
12700 if(!isWasmInitialized) {
12701 throw new Error("initializeWasm() must be awaited first!");
12703 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12704 return nativeResponseValue;
12706 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12708 export function CResult_StringErrorZ_ok(o: number): bigint {
12709 if(!isWasmInitialized) {
12710 throw new Error("initializeWasm() must be awaited first!");
12712 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12713 return nativeResponseValue;
12715 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12717 export function CResult_StringErrorZ_err(e: Secp256k1Error): bigint {
12718 if(!isWasmInitialized) {
12719 throw new Error("initializeWasm() must be awaited first!");
12721 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12722 return nativeResponseValue;
12724 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12726 export function CResult_StringErrorZ_is_ok(o: bigint): boolean {
12727 if(!isWasmInitialized) {
12728 throw new Error("initializeWasm() must be awaited first!");
12730 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12731 return nativeResponseValue;
12733 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12735 export function CResult_StringErrorZ_free(_res: bigint): void {
12736 if(!isWasmInitialized) {
12737 throw new Error("initializeWasm() must be awaited first!");
12739 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12740 // debug statements here
12742 // uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12744 export function CResult_StringErrorZ_clone_ptr(arg: bigint): bigint {
12745 if(!isWasmInitialized) {
12746 throw new Error("initializeWasm() must be awaited first!");
12748 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12749 return nativeResponseValue;
12751 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12753 export function CResult_StringErrorZ_clone(orig: bigint): bigint {
12754 if(!isWasmInitialized) {
12755 throw new Error("initializeWasm() must be awaited first!");
12757 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12758 return nativeResponseValue;
12760 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12762 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
12763 if(!isWasmInitialized) {
12764 throw new Error("initializeWasm() must be awaited first!");
12766 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12767 return nativeResponseValue;
12769 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12771 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
12772 if(!isWasmInitialized) {
12773 throw new Error("initializeWasm() must be awaited first!");
12775 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12776 return nativeResponseValue;
12778 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12780 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
12781 if(!isWasmInitialized) {
12782 throw new Error("initializeWasm() must be awaited first!");
12784 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12785 return nativeResponseValue;
12787 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12789 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
12790 if(!isWasmInitialized) {
12791 throw new Error("initializeWasm() must be awaited first!");
12793 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12794 // debug statements here
12796 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12798 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12799 if(!isWasmInitialized) {
12800 throw new Error("initializeWasm() must be awaited first!");
12802 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12803 return nativeResponseValue;
12805 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12807 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
12808 if(!isWasmInitialized) {
12809 throw new Error("initializeWasm() must be awaited first!");
12811 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12812 return nativeResponseValue;
12814 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12816 export function COption_MonitorEventZ_some(o: bigint): bigint {
12817 if(!isWasmInitialized) {
12818 throw new Error("initializeWasm() must be awaited first!");
12820 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12821 return nativeResponseValue;
12823 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12825 export function COption_MonitorEventZ_none(): bigint {
12826 if(!isWasmInitialized) {
12827 throw new Error("initializeWasm() must be awaited first!");
12829 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12830 return nativeResponseValue;
12832 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12834 export function COption_MonitorEventZ_free(_res: bigint): void {
12835 if(!isWasmInitialized) {
12836 throw new Error("initializeWasm() must be awaited first!");
12838 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12839 // debug statements here
12841 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12843 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
12844 if(!isWasmInitialized) {
12845 throw new Error("initializeWasm() must be awaited first!");
12847 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12848 return nativeResponseValue;
12850 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12852 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
12853 if(!isWasmInitialized) {
12854 throw new Error("initializeWasm() must be awaited first!");
12856 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12857 return nativeResponseValue;
12859 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12861 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
12862 if(!isWasmInitialized) {
12863 throw new Error("initializeWasm() must be awaited first!");
12865 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12866 return nativeResponseValue;
12868 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12870 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
12871 if(!isWasmInitialized) {
12872 throw new Error("initializeWasm() must be awaited first!");
12874 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12875 return nativeResponseValue;
12877 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12879 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
12880 if(!isWasmInitialized) {
12881 throw new Error("initializeWasm() must be awaited first!");
12883 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12884 return nativeResponseValue;
12886 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12888 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
12889 if(!isWasmInitialized) {
12890 throw new Error("initializeWasm() must be awaited first!");
12892 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12893 // debug statements here
12895 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12897 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12898 if(!isWasmInitialized) {
12899 throw new Error("initializeWasm() must be awaited first!");
12901 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12902 return nativeResponseValue;
12904 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12906 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
12907 if(!isWasmInitialized) {
12908 throw new Error("initializeWasm() must be awaited first!");
12910 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12911 return nativeResponseValue;
12913 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12915 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
12916 if(!isWasmInitialized) {
12917 throw new Error("initializeWasm() must be awaited first!");
12919 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12920 return nativeResponseValue;
12922 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12924 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
12925 if(!isWasmInitialized) {
12926 throw new Error("initializeWasm() must be awaited first!");
12928 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12929 return nativeResponseValue;
12931 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12933 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
12934 if(!isWasmInitialized) {
12935 throw new Error("initializeWasm() must be awaited first!");
12937 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12938 return nativeResponseValue;
12940 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12942 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
12943 if(!isWasmInitialized) {
12944 throw new Error("initializeWasm() must be awaited first!");
12946 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12947 // debug statements here
12949 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12951 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12952 if(!isWasmInitialized) {
12953 throw new Error("initializeWasm() must be awaited first!");
12955 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12956 return nativeResponseValue;
12958 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12960 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
12961 if(!isWasmInitialized) {
12962 throw new Error("initializeWasm() must be awaited first!");
12964 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12965 return nativeResponseValue;
12967 // uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12969 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: bigint): bigint {
12970 if(!isWasmInitialized) {
12971 throw new Error("initializeWasm() must be awaited first!");
12973 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12974 return nativeResponseValue;
12976 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12978 export function C2Tuple_OutPointScriptZ_clone(orig: bigint): bigint {
12979 if(!isWasmInitialized) {
12980 throw new Error("initializeWasm() must be awaited first!");
12982 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12983 return nativeResponseValue;
12985 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12987 export function C2Tuple_OutPointScriptZ_new(a: bigint, b: number): bigint {
12988 if(!isWasmInitialized) {
12989 throw new Error("initializeWasm() must be awaited first!");
12991 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12992 return nativeResponseValue;
12994 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12996 export function C2Tuple_OutPointScriptZ_free(_res: bigint): void {
12997 if(!isWasmInitialized) {
12998 throw new Error("initializeWasm() must be awaited first!");
13000 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
13001 // debug statements here
13003 // uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
13005 export function C2Tuple_u32ScriptZ_clone_ptr(arg: bigint): bigint {
13006 if(!isWasmInitialized) {
13007 throw new Error("initializeWasm() must be awaited first!");
13009 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
13010 return nativeResponseValue;
13012 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
13014 export function C2Tuple_u32ScriptZ_clone(orig: bigint): bigint {
13015 if(!isWasmInitialized) {
13016 throw new Error("initializeWasm() must be awaited first!");
13018 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
13019 return nativeResponseValue;
13021 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
13023 export function C2Tuple_u32ScriptZ_new(a: number, b: number): bigint {
13024 if(!isWasmInitialized) {
13025 throw new Error("initializeWasm() must be awaited first!");
13027 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
13028 return nativeResponseValue;
13030 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
13032 export function C2Tuple_u32ScriptZ_free(_res: bigint): void {
13033 if(!isWasmInitialized) {
13034 throw new Error("initializeWasm() must be awaited first!");
13036 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
13037 // debug statements here
13039 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
13041 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
13042 if(!isWasmInitialized) {
13043 throw new Error("initializeWasm() must be awaited first!");
13045 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
13046 // debug statements here
13048 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
13050 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: bigint): bigint {
13051 if(!isWasmInitialized) {
13052 throw new Error("initializeWasm() must be awaited first!");
13054 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
13055 return nativeResponseValue;
13057 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
13059 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: bigint): bigint {
13060 if(!isWasmInitialized) {
13061 throw new Error("initializeWasm() must be awaited first!");
13063 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
13064 return nativeResponseValue;
13066 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
13068 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): bigint {
13069 if(!isWasmInitialized) {
13070 throw new Error("initializeWasm() must be awaited first!");
13072 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
13073 return nativeResponseValue;
13075 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
13077 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: bigint): void {
13078 if(!isWasmInitialized) {
13079 throw new Error("initializeWasm() must be awaited first!");
13081 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
13082 // debug statements here
13084 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
13086 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
13087 if(!isWasmInitialized) {
13088 throw new Error("initializeWasm() must be awaited first!");
13090 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
13091 // debug statements here
13093 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
13095 export function CVec_EventZ_free(_res: number): void {
13096 if(!isWasmInitialized) {
13097 throw new Error("initializeWasm() must be awaited first!");
13099 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
13100 // debug statements here
13102 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
13104 export function CVec_TransactionZ_free(_res: number): void {
13105 if(!isWasmInitialized) {
13106 throw new Error("initializeWasm() must be awaited first!");
13108 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
13109 // debug statements here
13111 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
13113 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
13114 if(!isWasmInitialized) {
13115 throw new Error("initializeWasm() must be awaited first!");
13117 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
13118 return nativeResponseValue;
13120 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
13122 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
13123 if(!isWasmInitialized) {
13124 throw new Error("initializeWasm() must be awaited first!");
13126 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
13127 return nativeResponseValue;
13129 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
13131 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
13132 if(!isWasmInitialized) {
13133 throw new Error("initializeWasm() must be awaited first!");
13135 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
13136 return nativeResponseValue;
13138 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
13140 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
13141 if(!isWasmInitialized) {
13142 throw new Error("initializeWasm() must be awaited first!");
13144 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
13145 // debug statements here
13147 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
13149 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
13150 if(!isWasmInitialized) {
13151 throw new Error("initializeWasm() must be awaited first!");
13153 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
13154 // debug statements here
13156 // uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
13158 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
13159 if(!isWasmInitialized) {
13160 throw new Error("initializeWasm() must be awaited first!");
13162 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
13163 return nativeResponseValue;
13165 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
13167 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
13168 if(!isWasmInitialized) {
13169 throw new Error("initializeWasm() must be awaited first!");
13171 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
13172 return nativeResponseValue;
13174 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
13176 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
13177 if(!isWasmInitialized) {
13178 throw new Error("initializeWasm() must be awaited first!");
13180 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
13181 return nativeResponseValue;
13183 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
13185 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
13186 if(!isWasmInitialized) {
13187 throw new Error("initializeWasm() must be awaited first!");
13189 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
13190 // debug statements here
13192 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
13194 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
13195 if(!isWasmInitialized) {
13196 throw new Error("initializeWasm() must be awaited first!");
13198 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
13199 // debug statements here
13201 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
13203 export function CVec_BalanceZ_free(_res: number): void {
13204 if(!isWasmInitialized) {
13205 throw new Error("initializeWasm() must be awaited first!");
13207 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
13208 // debug statements here
13210 // uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
13212 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: bigint): bigint {
13213 if(!isWasmInitialized) {
13214 throw new Error("initializeWasm() must be awaited first!");
13216 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
13217 return nativeResponseValue;
13219 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
13221 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: bigint): bigint {
13222 if(!isWasmInitialized) {
13223 throw new Error("initializeWasm() must be awaited first!");
13225 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
13226 return nativeResponseValue;
13228 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
13230 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: bigint): bigint {
13231 if(!isWasmInitialized) {
13232 throw new Error("initializeWasm() must be awaited first!");
13234 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
13235 return nativeResponseValue;
13237 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
13239 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: bigint): void {
13240 if(!isWasmInitialized) {
13241 throw new Error("initializeWasm() must be awaited first!");
13243 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
13244 // debug statements here
13246 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
13248 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
13249 if(!isWasmInitialized) {
13250 throw new Error("initializeWasm() must be awaited first!");
13252 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
13253 return nativeResponseValue;
13255 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
13257 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
13258 if(!isWasmInitialized) {
13259 throw new Error("initializeWasm() must be awaited first!");
13261 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
13262 return nativeResponseValue;
13264 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
13266 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
13267 if(!isWasmInitialized) {
13268 throw new Error("initializeWasm() must be awaited first!");
13270 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
13271 return nativeResponseValue;
13273 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
13275 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
13276 if(!isWasmInitialized) {
13277 throw new Error("initializeWasm() must be awaited first!");
13279 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
13280 // debug statements here
13282 // uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
13284 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13285 if(!isWasmInitialized) {
13286 throw new Error("initializeWasm() must be awaited first!");
13288 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
13289 return nativeResponseValue;
13291 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
13293 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
13294 if(!isWasmInitialized) {
13295 throw new Error("initializeWasm() must be awaited first!");
13297 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
13298 return nativeResponseValue;
13300 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
13302 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
13303 if(!isWasmInitialized) {
13304 throw new Error("initializeWasm() must be awaited first!");
13306 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
13307 return nativeResponseValue;
13309 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
13311 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
13312 if(!isWasmInitialized) {
13313 throw new Error("initializeWasm() must be awaited first!");
13315 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
13316 return nativeResponseValue;
13318 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
13320 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
13321 if(!isWasmInitialized) {
13322 throw new Error("initializeWasm() must be awaited first!");
13324 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
13325 return nativeResponseValue;
13327 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
13329 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
13330 if(!isWasmInitialized) {
13331 throw new Error("initializeWasm() must be awaited first!");
13333 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
13334 // debug statements here
13336 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
13338 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
13339 if(!isWasmInitialized) {
13340 throw new Error("initializeWasm() must be awaited first!");
13342 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
13343 // debug statements here
13345 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
13347 export function COption_NetAddressZ_some(o: bigint): bigint {
13348 if(!isWasmInitialized) {
13349 throw new Error("initializeWasm() must be awaited first!");
13351 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
13352 return nativeResponseValue;
13354 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
13356 export function COption_NetAddressZ_none(): bigint {
13357 if(!isWasmInitialized) {
13358 throw new Error("initializeWasm() must be awaited first!");
13360 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
13361 return nativeResponseValue;
13363 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
13365 export function COption_NetAddressZ_free(_res: bigint): void {
13366 if(!isWasmInitialized) {
13367 throw new Error("initializeWasm() must be awaited first!");
13369 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
13370 // debug statements here
13372 // uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
13374 export function COption_NetAddressZ_clone_ptr(arg: bigint): bigint {
13375 if(!isWasmInitialized) {
13376 throw new Error("initializeWasm() must be awaited first!");
13378 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
13379 return nativeResponseValue;
13381 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
13383 export function COption_NetAddressZ_clone(orig: bigint): bigint {
13384 if(!isWasmInitialized) {
13385 throw new Error("initializeWasm() must be awaited first!");
13387 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
13388 return nativeResponseValue;
13390 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
13392 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
13393 if(!isWasmInitialized) {
13394 throw new Error("initializeWasm() must be awaited first!");
13396 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
13397 return nativeResponseValue;
13399 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13401 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
13402 if(!isWasmInitialized) {
13403 throw new Error("initializeWasm() must be awaited first!");
13405 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
13406 return nativeResponseValue;
13408 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
13410 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
13411 if(!isWasmInitialized) {
13412 throw new Error("initializeWasm() must be awaited first!");
13414 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
13415 return nativeResponseValue;
13417 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
13419 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
13420 if(!isWasmInitialized) {
13421 throw new Error("initializeWasm() must be awaited first!");
13423 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
13424 // debug statements here
13426 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
13428 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
13429 if(!isWasmInitialized) {
13430 throw new Error("initializeWasm() must be awaited first!");
13432 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
13433 return nativeResponseValue;
13435 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
13437 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
13438 if(!isWasmInitialized) {
13439 throw new Error("initializeWasm() must be awaited first!");
13441 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
13442 return nativeResponseValue;
13444 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
13446 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
13447 if(!isWasmInitialized) {
13448 throw new Error("initializeWasm() must be awaited first!");
13450 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
13451 return nativeResponseValue;
13453 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
13455 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
13456 if(!isWasmInitialized) {
13457 throw new Error("initializeWasm() must be awaited first!");
13459 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
13460 return nativeResponseValue;
13462 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
13464 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
13465 if(!isWasmInitialized) {
13466 throw new Error("initializeWasm() must be awaited first!");
13468 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
13469 return nativeResponseValue;
13471 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
13473 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
13474 if(!isWasmInitialized) {
13475 throw new Error("initializeWasm() must be awaited first!");
13477 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
13478 // debug statements here
13480 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
13482 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
13483 if(!isWasmInitialized) {
13484 throw new Error("initializeWasm() must be awaited first!");
13486 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
13487 return nativeResponseValue;
13489 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
13491 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
13492 if(!isWasmInitialized) {
13493 throw new Error("initializeWasm() must be awaited first!");
13495 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
13496 return nativeResponseValue;
13498 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
13500 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
13501 if(!isWasmInitialized) {
13502 throw new Error("initializeWasm() must be awaited first!");
13504 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
13505 return nativeResponseValue;
13507 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13509 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
13510 if(!isWasmInitialized) {
13511 throw new Error("initializeWasm() must be awaited first!");
13513 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
13514 return nativeResponseValue;
13516 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
13518 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
13519 if(!isWasmInitialized) {
13520 throw new Error("initializeWasm() must be awaited first!");
13522 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
13523 return nativeResponseValue;
13525 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
13527 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
13528 if(!isWasmInitialized) {
13529 throw new Error("initializeWasm() must be awaited first!");
13531 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
13532 // debug statements here
13534 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
13536 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
13537 if(!isWasmInitialized) {
13538 throw new Error("initializeWasm() must be awaited first!");
13540 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
13541 return nativeResponseValue;
13543 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
13545 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
13546 if(!isWasmInitialized) {
13547 throw new Error("initializeWasm() must be awaited first!");
13549 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
13550 return nativeResponseValue;
13552 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
13554 export function CResult_NoneErrorZ_ok(): bigint {
13555 if(!isWasmInitialized) {
13556 throw new Error("initializeWasm() must be awaited first!");
13558 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
13559 return nativeResponseValue;
13561 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
13563 export function CResult_NoneErrorZ_err(e: IOError): bigint {
13564 if(!isWasmInitialized) {
13565 throw new Error("initializeWasm() must be awaited first!");
13567 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
13568 return nativeResponseValue;
13570 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
13572 export function CResult_NoneErrorZ_is_ok(o: bigint): boolean {
13573 if(!isWasmInitialized) {
13574 throw new Error("initializeWasm() must be awaited first!");
13576 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13577 return nativeResponseValue;
13579 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13581 export function CResult_NoneErrorZ_free(_res: bigint): void {
13582 if(!isWasmInitialized) {
13583 throw new Error("initializeWasm() must be awaited first!");
13585 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13586 // debug statements here
13588 // uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13590 export function CResult_NoneErrorZ_clone_ptr(arg: bigint): bigint {
13591 if(!isWasmInitialized) {
13592 throw new Error("initializeWasm() must be awaited first!");
13594 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13595 return nativeResponseValue;
13597 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13599 export function CResult_NoneErrorZ_clone(orig: bigint): bigint {
13600 if(!isWasmInitialized) {
13601 throw new Error("initializeWasm() must be awaited first!");
13603 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13604 return nativeResponseValue;
13606 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13608 export function CResult_NetAddressDecodeErrorZ_ok(o: bigint): bigint {
13609 if(!isWasmInitialized) {
13610 throw new Error("initializeWasm() must be awaited first!");
13612 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13613 return nativeResponseValue;
13615 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13617 export function CResult_NetAddressDecodeErrorZ_err(e: bigint): bigint {
13618 if(!isWasmInitialized) {
13619 throw new Error("initializeWasm() must be awaited first!");
13621 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13622 return nativeResponseValue;
13624 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13626 export function CResult_NetAddressDecodeErrorZ_is_ok(o: bigint): boolean {
13627 if(!isWasmInitialized) {
13628 throw new Error("initializeWasm() must be awaited first!");
13630 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13631 return nativeResponseValue;
13633 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13635 export function CResult_NetAddressDecodeErrorZ_free(_res: bigint): void {
13636 if(!isWasmInitialized) {
13637 throw new Error("initializeWasm() must be awaited first!");
13639 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13640 // debug statements here
13642 // uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13644 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13645 if(!isWasmInitialized) {
13646 throw new Error("initializeWasm() must be awaited first!");
13648 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13649 return nativeResponseValue;
13651 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13653 export function CResult_NetAddressDecodeErrorZ_clone(orig: bigint): bigint {
13654 if(!isWasmInitialized) {
13655 throw new Error("initializeWasm() must be awaited first!");
13657 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13658 return nativeResponseValue;
13660 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13662 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13663 if(!isWasmInitialized) {
13664 throw new Error("initializeWasm() must be awaited first!");
13666 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13667 // debug statements here
13669 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13671 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13672 if(!isWasmInitialized) {
13673 throw new Error("initializeWasm() must be awaited first!");
13675 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13676 // debug statements here
13678 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13680 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13681 if(!isWasmInitialized) {
13682 throw new Error("initializeWasm() must be awaited first!");
13684 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13685 // debug statements here
13687 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13689 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13690 if(!isWasmInitialized) {
13691 throw new Error("initializeWasm() must be awaited first!");
13693 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13694 // debug statements here
13696 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13698 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
13699 if(!isWasmInitialized) {
13700 throw new Error("initializeWasm() must be awaited first!");
13702 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13703 return nativeResponseValue;
13705 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13707 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
13708 if(!isWasmInitialized) {
13709 throw new Error("initializeWasm() must be awaited first!");
13711 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13712 return nativeResponseValue;
13714 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13716 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
13717 if(!isWasmInitialized) {
13718 throw new Error("initializeWasm() must be awaited first!");
13720 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13721 return nativeResponseValue;
13723 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13725 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
13726 if(!isWasmInitialized) {
13727 throw new Error("initializeWasm() must be awaited first!");
13729 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13730 // debug statements here
13732 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13734 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13735 if(!isWasmInitialized) {
13736 throw new Error("initializeWasm() must be awaited first!");
13738 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13739 return nativeResponseValue;
13741 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13743 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
13744 if(!isWasmInitialized) {
13745 throw new Error("initializeWasm() must be awaited first!");
13747 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13748 return nativeResponseValue;
13750 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13752 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
13753 if(!isWasmInitialized) {
13754 throw new Error("initializeWasm() must be awaited first!");
13756 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13757 return nativeResponseValue;
13759 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13761 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
13762 if(!isWasmInitialized) {
13763 throw new Error("initializeWasm() must be awaited first!");
13765 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13766 return nativeResponseValue;
13768 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13770 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
13771 if(!isWasmInitialized) {
13772 throw new Error("initializeWasm() must be awaited first!");
13774 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13775 return nativeResponseValue;
13777 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13779 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
13780 if(!isWasmInitialized) {
13781 throw new Error("initializeWasm() must be awaited first!");
13783 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13784 // debug statements here
13786 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13788 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13789 if(!isWasmInitialized) {
13790 throw new Error("initializeWasm() must be awaited first!");
13792 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13793 return nativeResponseValue;
13795 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13797 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
13798 if(!isWasmInitialized) {
13799 throw new Error("initializeWasm() must be awaited first!");
13801 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13802 return nativeResponseValue;
13804 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13806 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
13807 if(!isWasmInitialized) {
13808 throw new Error("initializeWasm() must be awaited first!");
13810 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13811 return nativeResponseValue;
13813 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13815 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
13816 if(!isWasmInitialized) {
13817 throw new Error("initializeWasm() must be awaited first!");
13819 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13820 return nativeResponseValue;
13822 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13824 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
13825 if(!isWasmInitialized) {
13826 throw new Error("initializeWasm() must be awaited first!");
13828 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13829 return nativeResponseValue;
13831 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13833 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
13834 if(!isWasmInitialized) {
13835 throw new Error("initializeWasm() must be awaited first!");
13837 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13838 // debug statements here
13840 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13842 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13843 if(!isWasmInitialized) {
13844 throw new Error("initializeWasm() must be awaited first!");
13846 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13847 return nativeResponseValue;
13849 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13851 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
13852 if(!isWasmInitialized) {
13853 throw new Error("initializeWasm() must be awaited first!");
13855 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13856 return nativeResponseValue;
13858 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13860 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
13861 if(!isWasmInitialized) {
13862 throw new Error("initializeWasm() must be awaited first!");
13864 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13865 return nativeResponseValue;
13867 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13869 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
13870 if(!isWasmInitialized) {
13871 throw new Error("initializeWasm() must be awaited first!");
13873 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13874 return nativeResponseValue;
13876 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13878 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
13879 if(!isWasmInitialized) {
13880 throw new Error("initializeWasm() must be awaited first!");
13882 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13883 return nativeResponseValue;
13885 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13887 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
13888 if(!isWasmInitialized) {
13889 throw new Error("initializeWasm() must be awaited first!");
13891 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13892 // debug statements here
13894 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13896 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13897 if(!isWasmInitialized) {
13898 throw new Error("initializeWasm() must be awaited first!");
13900 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13901 return nativeResponseValue;
13903 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13905 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
13906 if(!isWasmInitialized) {
13907 throw new Error("initializeWasm() must be awaited first!");
13909 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13910 return nativeResponseValue;
13912 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13914 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
13915 if(!isWasmInitialized) {
13916 throw new Error("initializeWasm() must be awaited first!");
13918 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13919 return nativeResponseValue;
13921 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13923 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
13924 if(!isWasmInitialized) {
13925 throw new Error("initializeWasm() must be awaited first!");
13927 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13928 return nativeResponseValue;
13930 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13932 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
13933 if(!isWasmInitialized) {
13934 throw new Error("initializeWasm() must be awaited first!");
13936 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13937 return nativeResponseValue;
13939 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13941 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
13942 if(!isWasmInitialized) {
13943 throw new Error("initializeWasm() must be awaited first!");
13945 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13946 // debug statements here
13948 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13950 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13951 if(!isWasmInitialized) {
13952 throw new Error("initializeWasm() must be awaited first!");
13954 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13955 return nativeResponseValue;
13957 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13959 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
13960 if(!isWasmInitialized) {
13961 throw new Error("initializeWasm() must be awaited first!");
13963 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13964 return nativeResponseValue;
13966 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13968 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
13969 if(!isWasmInitialized) {
13970 throw new Error("initializeWasm() must be awaited first!");
13972 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13973 return nativeResponseValue;
13975 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13977 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
13978 if(!isWasmInitialized) {
13979 throw new Error("initializeWasm() must be awaited first!");
13981 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13982 return nativeResponseValue;
13984 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13986 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
13987 if(!isWasmInitialized) {
13988 throw new Error("initializeWasm() must be awaited first!");
13990 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13991 return nativeResponseValue;
13993 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13995 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
13996 if(!isWasmInitialized) {
13997 throw new Error("initializeWasm() must be awaited first!");
13999 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
14000 // debug statements here
14002 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
14004 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14005 if(!isWasmInitialized) {
14006 throw new Error("initializeWasm() must be awaited first!");
14008 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
14009 return nativeResponseValue;
14011 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
14013 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
14014 if(!isWasmInitialized) {
14015 throw new Error("initializeWasm() must be awaited first!");
14017 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
14018 return nativeResponseValue;
14020 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
14022 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
14023 if(!isWasmInitialized) {
14024 throw new Error("initializeWasm() must be awaited first!");
14026 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
14027 return nativeResponseValue;
14029 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
14031 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
14032 if(!isWasmInitialized) {
14033 throw new Error("initializeWasm() must be awaited first!");
14035 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
14036 return nativeResponseValue;
14038 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
14040 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
14041 if(!isWasmInitialized) {
14042 throw new Error("initializeWasm() must be awaited first!");
14044 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
14045 return nativeResponseValue;
14047 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
14049 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
14050 if(!isWasmInitialized) {
14051 throw new Error("initializeWasm() must be awaited first!");
14053 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
14054 // debug statements here
14056 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
14058 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14059 if(!isWasmInitialized) {
14060 throw new Error("initializeWasm() must be awaited first!");
14062 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
14063 return nativeResponseValue;
14065 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
14067 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
14068 if(!isWasmInitialized) {
14069 throw new Error("initializeWasm() must be awaited first!");
14071 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
14072 return nativeResponseValue;
14074 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
14076 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
14077 if(!isWasmInitialized) {
14078 throw new Error("initializeWasm() must be awaited first!");
14080 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
14081 return nativeResponseValue;
14083 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
14085 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
14086 if(!isWasmInitialized) {
14087 throw new Error("initializeWasm() must be awaited first!");
14089 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
14090 return nativeResponseValue;
14092 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
14094 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
14095 if(!isWasmInitialized) {
14096 throw new Error("initializeWasm() must be awaited first!");
14098 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
14099 return nativeResponseValue;
14101 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
14103 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
14104 if(!isWasmInitialized) {
14105 throw new Error("initializeWasm() must be awaited first!");
14107 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
14108 // debug statements here
14110 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
14112 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14113 if(!isWasmInitialized) {
14114 throw new Error("initializeWasm() must be awaited first!");
14116 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
14117 return nativeResponseValue;
14119 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
14121 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
14122 if(!isWasmInitialized) {
14123 throw new Error("initializeWasm() must be awaited first!");
14125 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
14126 return nativeResponseValue;
14128 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
14130 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
14131 if(!isWasmInitialized) {
14132 throw new Error("initializeWasm() must be awaited first!");
14134 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
14135 return nativeResponseValue;
14137 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
14139 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
14140 if(!isWasmInitialized) {
14141 throw new Error("initializeWasm() must be awaited first!");
14143 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
14144 return nativeResponseValue;
14146 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
14148 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
14149 if(!isWasmInitialized) {
14150 throw new Error("initializeWasm() must be awaited first!");
14152 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
14153 return nativeResponseValue;
14155 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
14157 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
14158 if(!isWasmInitialized) {
14159 throw new Error("initializeWasm() must be awaited first!");
14161 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
14162 // debug statements here
14164 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
14166 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14167 if(!isWasmInitialized) {
14168 throw new Error("initializeWasm() must be awaited first!");
14170 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
14171 return nativeResponseValue;
14173 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
14175 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
14176 if(!isWasmInitialized) {
14177 throw new Error("initializeWasm() must be awaited first!");
14179 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
14180 return nativeResponseValue;
14182 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
14184 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
14185 if(!isWasmInitialized) {
14186 throw new Error("initializeWasm() must be awaited first!");
14188 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
14189 return nativeResponseValue;
14191 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
14193 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
14194 if(!isWasmInitialized) {
14195 throw new Error("initializeWasm() must be awaited first!");
14197 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
14198 return nativeResponseValue;
14200 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
14202 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
14203 if(!isWasmInitialized) {
14204 throw new Error("initializeWasm() must be awaited first!");
14206 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
14207 return nativeResponseValue;
14209 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
14211 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
14212 if(!isWasmInitialized) {
14213 throw new Error("initializeWasm() must be awaited first!");
14215 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
14216 // debug statements here
14218 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
14220 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14221 if(!isWasmInitialized) {
14222 throw new Error("initializeWasm() must be awaited first!");
14224 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
14225 return nativeResponseValue;
14227 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
14229 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
14230 if(!isWasmInitialized) {
14231 throw new Error("initializeWasm() must be awaited first!");
14233 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
14234 return nativeResponseValue;
14236 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
14238 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
14239 if(!isWasmInitialized) {
14240 throw new Error("initializeWasm() must be awaited first!");
14242 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
14243 return nativeResponseValue;
14245 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
14247 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
14248 if(!isWasmInitialized) {
14249 throw new Error("initializeWasm() must be awaited first!");
14251 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
14252 return nativeResponseValue;
14254 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
14256 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
14257 if(!isWasmInitialized) {
14258 throw new Error("initializeWasm() must be awaited first!");
14260 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
14261 return nativeResponseValue;
14263 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
14265 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
14266 if(!isWasmInitialized) {
14267 throw new Error("initializeWasm() must be awaited first!");
14269 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
14270 // debug statements here
14272 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
14274 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14275 if(!isWasmInitialized) {
14276 throw new Error("initializeWasm() must be awaited first!");
14278 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
14279 return nativeResponseValue;
14281 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
14283 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
14284 if(!isWasmInitialized) {
14285 throw new Error("initializeWasm() must be awaited first!");
14287 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
14288 return nativeResponseValue;
14290 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
14292 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
14293 if(!isWasmInitialized) {
14294 throw new Error("initializeWasm() must be awaited first!");
14296 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
14297 return nativeResponseValue;
14299 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
14301 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
14302 if(!isWasmInitialized) {
14303 throw new Error("initializeWasm() must be awaited first!");
14305 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
14306 return nativeResponseValue;
14308 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
14310 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
14311 if(!isWasmInitialized) {
14312 throw new Error("initializeWasm() must be awaited first!");
14314 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
14315 return nativeResponseValue;
14317 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
14319 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
14320 if(!isWasmInitialized) {
14321 throw new Error("initializeWasm() must be awaited first!");
14323 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
14324 // debug statements here
14326 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
14328 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14329 if(!isWasmInitialized) {
14330 throw new Error("initializeWasm() must be awaited first!");
14332 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
14333 return nativeResponseValue;
14335 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
14337 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
14338 if(!isWasmInitialized) {
14339 throw new Error("initializeWasm() must be awaited first!");
14341 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
14342 return nativeResponseValue;
14344 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
14346 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
14347 if(!isWasmInitialized) {
14348 throw new Error("initializeWasm() must be awaited first!");
14350 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
14351 return nativeResponseValue;
14353 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
14355 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
14356 if(!isWasmInitialized) {
14357 throw new Error("initializeWasm() must be awaited first!");
14359 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
14360 return nativeResponseValue;
14362 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
14364 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
14365 if(!isWasmInitialized) {
14366 throw new Error("initializeWasm() must be awaited first!");
14368 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
14369 return nativeResponseValue;
14371 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
14373 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
14374 if(!isWasmInitialized) {
14375 throw new Error("initializeWasm() must be awaited first!");
14377 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
14378 // debug statements here
14380 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
14382 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14383 if(!isWasmInitialized) {
14384 throw new Error("initializeWasm() must be awaited first!");
14386 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
14387 return nativeResponseValue;
14389 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
14391 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
14392 if(!isWasmInitialized) {
14393 throw new Error("initializeWasm() must be awaited first!");
14395 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
14396 return nativeResponseValue;
14398 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
14400 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
14401 if(!isWasmInitialized) {
14402 throw new Error("initializeWasm() must be awaited first!");
14404 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
14405 return nativeResponseValue;
14407 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14409 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
14410 if(!isWasmInitialized) {
14411 throw new Error("initializeWasm() must be awaited first!");
14413 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
14414 return nativeResponseValue;
14416 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
14418 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
14419 if(!isWasmInitialized) {
14420 throw new Error("initializeWasm() must be awaited first!");
14422 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
14423 return nativeResponseValue;
14425 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
14427 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
14428 if(!isWasmInitialized) {
14429 throw new Error("initializeWasm() must be awaited first!");
14431 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
14432 // debug statements here
14434 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
14436 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14437 if(!isWasmInitialized) {
14438 throw new Error("initializeWasm() must be awaited first!");
14440 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
14441 return nativeResponseValue;
14443 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
14445 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
14446 if(!isWasmInitialized) {
14447 throw new Error("initializeWasm() must be awaited first!");
14449 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
14450 return nativeResponseValue;
14452 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
14454 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
14455 if(!isWasmInitialized) {
14456 throw new Error("initializeWasm() must be awaited first!");
14458 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
14459 return nativeResponseValue;
14461 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14463 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
14464 if(!isWasmInitialized) {
14465 throw new Error("initializeWasm() must be awaited first!");
14467 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
14468 return nativeResponseValue;
14470 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
14472 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
14473 if(!isWasmInitialized) {
14474 throw new Error("initializeWasm() must be awaited first!");
14476 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
14477 return nativeResponseValue;
14479 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
14481 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
14482 if(!isWasmInitialized) {
14483 throw new Error("initializeWasm() must be awaited first!");
14485 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
14486 // debug statements here
14488 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
14490 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14491 if(!isWasmInitialized) {
14492 throw new Error("initializeWasm() must be awaited first!");
14494 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
14495 return nativeResponseValue;
14497 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
14499 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
14500 if(!isWasmInitialized) {
14501 throw new Error("initializeWasm() must be awaited first!");
14503 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
14504 return nativeResponseValue;
14506 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
14508 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
14509 if(!isWasmInitialized) {
14510 throw new Error("initializeWasm() must be awaited first!");
14512 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
14513 return nativeResponseValue;
14515 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
14517 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
14518 if(!isWasmInitialized) {
14519 throw new Error("initializeWasm() must be awaited first!");
14521 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
14522 return nativeResponseValue;
14524 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
14526 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
14527 if(!isWasmInitialized) {
14528 throw new Error("initializeWasm() must be awaited first!");
14530 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
14531 return nativeResponseValue;
14533 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
14535 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
14536 if(!isWasmInitialized) {
14537 throw new Error("initializeWasm() must be awaited first!");
14539 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
14540 // debug statements here
14542 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
14544 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14545 if(!isWasmInitialized) {
14546 throw new Error("initializeWasm() must be awaited first!");
14548 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
14549 return nativeResponseValue;
14551 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
14553 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
14554 if(!isWasmInitialized) {
14555 throw new Error("initializeWasm() must be awaited first!");
14557 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
14558 return nativeResponseValue;
14560 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
14562 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
14563 if(!isWasmInitialized) {
14564 throw new Error("initializeWasm() must be awaited first!");
14566 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
14567 return nativeResponseValue;
14569 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14571 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
14572 if(!isWasmInitialized) {
14573 throw new Error("initializeWasm() must be awaited first!");
14575 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14576 return nativeResponseValue;
14578 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14580 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
14581 if(!isWasmInitialized) {
14582 throw new Error("initializeWasm() must be awaited first!");
14584 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14585 return nativeResponseValue;
14587 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14589 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
14590 if(!isWasmInitialized) {
14591 throw new Error("initializeWasm() must be awaited first!");
14593 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14594 // debug statements here
14596 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14598 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14599 if(!isWasmInitialized) {
14600 throw new Error("initializeWasm() must be awaited first!");
14602 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14603 return nativeResponseValue;
14605 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14607 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
14608 if(!isWasmInitialized) {
14609 throw new Error("initializeWasm() must be awaited first!");
14611 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14612 return nativeResponseValue;
14614 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14616 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
14617 if(!isWasmInitialized) {
14618 throw new Error("initializeWasm() must be awaited first!");
14620 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14621 return nativeResponseValue;
14623 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14625 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
14626 if(!isWasmInitialized) {
14627 throw new Error("initializeWasm() must be awaited first!");
14629 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14630 return nativeResponseValue;
14632 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14634 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
14635 if(!isWasmInitialized) {
14636 throw new Error("initializeWasm() must be awaited first!");
14638 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14639 return nativeResponseValue;
14641 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14643 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
14644 if(!isWasmInitialized) {
14645 throw new Error("initializeWasm() must be awaited first!");
14647 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14648 // debug statements here
14650 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14652 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14653 if(!isWasmInitialized) {
14654 throw new Error("initializeWasm() must be awaited first!");
14656 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14657 return nativeResponseValue;
14659 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14661 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
14662 if(!isWasmInitialized) {
14663 throw new Error("initializeWasm() must be awaited first!");
14665 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14666 return nativeResponseValue;
14668 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14670 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
14671 if(!isWasmInitialized) {
14672 throw new Error("initializeWasm() must be awaited first!");
14674 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14675 return nativeResponseValue;
14677 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14679 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
14680 if(!isWasmInitialized) {
14681 throw new Error("initializeWasm() must be awaited first!");
14683 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14684 return nativeResponseValue;
14686 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14688 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
14689 if(!isWasmInitialized) {
14690 throw new Error("initializeWasm() must be awaited first!");
14692 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14693 return nativeResponseValue;
14695 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14697 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
14698 if(!isWasmInitialized) {
14699 throw new Error("initializeWasm() must be awaited first!");
14701 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14702 // debug statements here
14704 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14706 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14707 if(!isWasmInitialized) {
14708 throw new Error("initializeWasm() must be awaited first!");
14710 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14711 return nativeResponseValue;
14713 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14715 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
14716 if(!isWasmInitialized) {
14717 throw new Error("initializeWasm() must be awaited first!");
14719 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14720 return nativeResponseValue;
14722 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14724 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
14725 if(!isWasmInitialized) {
14726 throw new Error("initializeWasm() must be awaited first!");
14728 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14729 return nativeResponseValue;
14731 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14733 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
14734 if(!isWasmInitialized) {
14735 throw new Error("initializeWasm() must be awaited first!");
14737 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14738 return nativeResponseValue;
14740 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14742 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
14743 if(!isWasmInitialized) {
14744 throw new Error("initializeWasm() must be awaited first!");
14746 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14747 return nativeResponseValue;
14749 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14751 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
14752 if(!isWasmInitialized) {
14753 throw new Error("initializeWasm() must be awaited first!");
14755 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14756 // debug statements here
14758 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14760 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14761 if(!isWasmInitialized) {
14762 throw new Error("initializeWasm() must be awaited first!");
14764 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14765 return nativeResponseValue;
14767 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14769 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
14770 if(!isWasmInitialized) {
14771 throw new Error("initializeWasm() must be awaited first!");
14773 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14774 return nativeResponseValue;
14776 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14778 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
14779 if(!isWasmInitialized) {
14780 throw new Error("initializeWasm() must be awaited first!");
14782 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14783 return nativeResponseValue;
14785 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14787 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
14788 if(!isWasmInitialized) {
14789 throw new Error("initializeWasm() must be awaited first!");
14791 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14792 return nativeResponseValue;
14794 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14796 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
14797 if(!isWasmInitialized) {
14798 throw new Error("initializeWasm() must be awaited first!");
14800 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14801 return nativeResponseValue;
14803 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14805 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
14806 if(!isWasmInitialized) {
14807 throw new Error("initializeWasm() must be awaited first!");
14809 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14810 // debug statements here
14812 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14814 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14815 if(!isWasmInitialized) {
14816 throw new Error("initializeWasm() must be awaited first!");
14818 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14819 return nativeResponseValue;
14821 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14823 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
14824 if(!isWasmInitialized) {
14825 throw new Error("initializeWasm() must be awaited first!");
14827 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14828 return nativeResponseValue;
14830 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14832 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
14833 if(!isWasmInitialized) {
14834 throw new Error("initializeWasm() must be awaited first!");
14836 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14837 return nativeResponseValue;
14839 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14841 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
14842 if(!isWasmInitialized) {
14843 throw new Error("initializeWasm() must be awaited first!");
14845 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14846 return nativeResponseValue;
14848 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14850 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
14851 if(!isWasmInitialized) {
14852 throw new Error("initializeWasm() must be awaited first!");
14854 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14855 return nativeResponseValue;
14857 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14859 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
14860 if(!isWasmInitialized) {
14861 throw new Error("initializeWasm() must be awaited first!");
14863 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14864 // debug statements here
14866 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14868 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14869 if(!isWasmInitialized) {
14870 throw new Error("initializeWasm() must be awaited first!");
14872 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14873 return nativeResponseValue;
14875 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14877 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
14878 if(!isWasmInitialized) {
14879 throw new Error("initializeWasm() must be awaited first!");
14881 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14882 return nativeResponseValue;
14884 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14886 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
14887 if(!isWasmInitialized) {
14888 throw new Error("initializeWasm() must be awaited first!");
14890 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14891 return nativeResponseValue;
14893 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14895 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
14896 if(!isWasmInitialized) {
14897 throw new Error("initializeWasm() must be awaited first!");
14899 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14900 return nativeResponseValue;
14902 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14904 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
14905 if(!isWasmInitialized) {
14906 throw new Error("initializeWasm() must be awaited first!");
14908 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14909 return nativeResponseValue;
14911 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14913 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
14914 if(!isWasmInitialized) {
14915 throw new Error("initializeWasm() must be awaited first!");
14917 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14918 // debug statements here
14920 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14922 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14923 if(!isWasmInitialized) {
14924 throw new Error("initializeWasm() must be awaited first!");
14926 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14927 return nativeResponseValue;
14929 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14931 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
14932 if(!isWasmInitialized) {
14933 throw new Error("initializeWasm() must be awaited first!");
14935 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14936 return nativeResponseValue;
14938 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14940 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
14941 if(!isWasmInitialized) {
14942 throw new Error("initializeWasm() must be awaited first!");
14944 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14945 return nativeResponseValue;
14947 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14949 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
14950 if(!isWasmInitialized) {
14951 throw new Error("initializeWasm() must be awaited first!");
14953 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14954 return nativeResponseValue;
14956 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14958 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
14959 if(!isWasmInitialized) {
14960 throw new Error("initializeWasm() must be awaited first!");
14962 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14963 return nativeResponseValue;
14965 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14967 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
14968 if(!isWasmInitialized) {
14969 throw new Error("initializeWasm() must be awaited first!");
14971 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14972 // debug statements here
14974 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14976 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14977 if(!isWasmInitialized) {
14978 throw new Error("initializeWasm() must be awaited first!");
14980 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14981 return nativeResponseValue;
14983 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14985 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
14986 if(!isWasmInitialized) {
14987 throw new Error("initializeWasm() must be awaited first!");
14989 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14990 return nativeResponseValue;
14992 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14994 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
14995 if(!isWasmInitialized) {
14996 throw new Error("initializeWasm() must be awaited first!");
14998 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14999 return nativeResponseValue;
15001 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
15003 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
15004 if(!isWasmInitialized) {
15005 throw new Error("initializeWasm() must be awaited first!");
15007 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
15008 return nativeResponseValue;
15010 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
15012 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
15013 if(!isWasmInitialized) {
15014 throw new Error("initializeWasm() must be awaited first!");
15016 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
15017 return nativeResponseValue;
15019 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
15021 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
15022 if(!isWasmInitialized) {
15023 throw new Error("initializeWasm() must be awaited first!");
15025 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
15026 // debug statements here
15028 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
15030 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15031 if(!isWasmInitialized) {
15032 throw new Error("initializeWasm() must be awaited first!");
15034 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
15035 return nativeResponseValue;
15037 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
15039 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
15040 if(!isWasmInitialized) {
15041 throw new Error("initializeWasm() must be awaited first!");
15043 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
15044 return nativeResponseValue;
15046 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
15048 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
15049 if(!isWasmInitialized) {
15050 throw new Error("initializeWasm() must be awaited first!");
15052 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
15053 return nativeResponseValue;
15055 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
15057 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
15058 if(!isWasmInitialized) {
15059 throw new Error("initializeWasm() must be awaited first!");
15061 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
15062 return nativeResponseValue;
15064 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
15066 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
15067 if(!isWasmInitialized) {
15068 throw new Error("initializeWasm() must be awaited first!");
15070 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
15071 return nativeResponseValue;
15073 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
15075 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
15076 if(!isWasmInitialized) {
15077 throw new Error("initializeWasm() must be awaited first!");
15079 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
15080 // debug statements here
15082 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
15084 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15085 if(!isWasmInitialized) {
15086 throw new Error("initializeWasm() must be awaited first!");
15088 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
15089 return nativeResponseValue;
15091 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
15093 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
15094 if(!isWasmInitialized) {
15095 throw new Error("initializeWasm() must be awaited first!");
15097 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
15098 return nativeResponseValue;
15100 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
15102 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15103 if(!isWasmInitialized) {
15104 throw new Error("initializeWasm() must be awaited first!");
15106 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
15107 return nativeResponseValue;
15109 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15111 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15112 if(!isWasmInitialized) {
15113 throw new Error("initializeWasm() must be awaited first!");
15115 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
15116 return nativeResponseValue;
15118 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15120 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15121 if(!isWasmInitialized) {
15122 throw new Error("initializeWasm() must be awaited first!");
15124 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
15125 return nativeResponseValue;
15127 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
15129 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
15130 if(!isWasmInitialized) {
15131 throw new Error("initializeWasm() must be awaited first!");
15133 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
15134 // debug statements here
15136 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15138 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15139 if(!isWasmInitialized) {
15140 throw new Error("initializeWasm() must be awaited first!");
15142 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
15143 return nativeResponseValue;
15145 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15147 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
15148 if(!isWasmInitialized) {
15149 throw new Error("initializeWasm() must be awaited first!");
15151 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
15152 return nativeResponseValue;
15154 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
15156 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
15157 if(!isWasmInitialized) {
15158 throw new Error("initializeWasm() must be awaited first!");
15160 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
15161 return nativeResponseValue;
15163 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15165 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
15166 if(!isWasmInitialized) {
15167 throw new Error("initializeWasm() must be awaited first!");
15169 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
15170 return nativeResponseValue;
15172 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15174 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
15175 if(!isWasmInitialized) {
15176 throw new Error("initializeWasm() must be awaited first!");
15178 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
15179 return nativeResponseValue;
15181 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
15183 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
15184 if(!isWasmInitialized) {
15185 throw new Error("initializeWasm() must be awaited first!");
15187 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
15188 // debug statements here
15190 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15192 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15193 if(!isWasmInitialized) {
15194 throw new Error("initializeWasm() must be awaited first!");
15196 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
15197 return nativeResponseValue;
15199 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15201 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
15202 if(!isWasmInitialized) {
15203 throw new Error("initializeWasm() must be awaited first!");
15205 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
15206 return nativeResponseValue;
15208 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
15210 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
15211 if(!isWasmInitialized) {
15212 throw new Error("initializeWasm() must be awaited first!");
15214 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
15215 return nativeResponseValue;
15217 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
15219 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
15220 if(!isWasmInitialized) {
15221 throw new Error("initializeWasm() must be awaited first!");
15223 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
15224 return nativeResponseValue;
15226 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
15228 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
15229 if(!isWasmInitialized) {
15230 throw new Error("initializeWasm() must be awaited first!");
15232 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
15233 return nativeResponseValue;
15235 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
15237 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
15238 if(!isWasmInitialized) {
15239 throw new Error("initializeWasm() must be awaited first!");
15241 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
15242 // debug statements here
15244 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
15246 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15247 if(!isWasmInitialized) {
15248 throw new Error("initializeWasm() must be awaited first!");
15250 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
15251 return nativeResponseValue;
15253 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
15255 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
15256 if(!isWasmInitialized) {
15257 throw new Error("initializeWasm() must be awaited first!");
15259 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
15260 return nativeResponseValue;
15262 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
15264 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
15265 if(!isWasmInitialized) {
15266 throw new Error("initializeWasm() must be awaited first!");
15268 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
15269 return nativeResponseValue;
15271 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
15273 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
15274 if(!isWasmInitialized) {
15275 throw new Error("initializeWasm() must be awaited first!");
15277 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
15278 return nativeResponseValue;
15280 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
15282 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
15283 if(!isWasmInitialized) {
15284 throw new Error("initializeWasm() must be awaited first!");
15286 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
15287 return nativeResponseValue;
15289 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
15291 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
15292 if(!isWasmInitialized) {
15293 throw new Error("initializeWasm() must be awaited first!");
15295 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
15296 // debug statements here
15298 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
15300 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15301 if(!isWasmInitialized) {
15302 throw new Error("initializeWasm() must be awaited first!");
15304 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
15305 return nativeResponseValue;
15307 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
15309 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
15310 if(!isWasmInitialized) {
15311 throw new Error("initializeWasm() must be awaited first!");
15313 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
15314 return nativeResponseValue;
15316 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
15318 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
15319 if(!isWasmInitialized) {
15320 throw new Error("initializeWasm() must be awaited first!");
15322 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
15323 return nativeResponseValue;
15325 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15327 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
15328 if(!isWasmInitialized) {
15329 throw new Error("initializeWasm() must be awaited first!");
15331 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
15332 return nativeResponseValue;
15334 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
15336 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
15337 if(!isWasmInitialized) {
15338 throw new Error("initializeWasm() must be awaited first!");
15340 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
15341 return nativeResponseValue;
15343 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
15345 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
15346 if(!isWasmInitialized) {
15347 throw new Error("initializeWasm() must be awaited first!");
15349 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
15350 // debug statements here
15352 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15354 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15355 if(!isWasmInitialized) {
15356 throw new Error("initializeWasm() must be awaited first!");
15358 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
15359 return nativeResponseValue;
15361 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15363 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
15364 if(!isWasmInitialized) {
15365 throw new Error("initializeWasm() must be awaited first!");
15367 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
15368 return nativeResponseValue;
15370 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
15372 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
15373 if(!isWasmInitialized) {
15374 throw new Error("initializeWasm() must be awaited first!");
15376 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
15377 return nativeResponseValue;
15379 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15381 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
15382 if(!isWasmInitialized) {
15383 throw new Error("initializeWasm() must be awaited first!");
15385 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
15386 return nativeResponseValue;
15388 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
15390 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
15391 if(!isWasmInitialized) {
15392 throw new Error("initializeWasm() must be awaited first!");
15394 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
15395 return nativeResponseValue;
15397 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
15399 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
15400 if(!isWasmInitialized) {
15401 throw new Error("initializeWasm() must be awaited first!");
15403 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
15404 // debug statements here
15406 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15408 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15409 if(!isWasmInitialized) {
15410 throw new Error("initializeWasm() must be awaited first!");
15412 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
15413 return nativeResponseValue;
15415 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15417 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
15418 if(!isWasmInitialized) {
15419 throw new Error("initializeWasm() must be awaited first!");
15421 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
15422 return nativeResponseValue;
15424 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
15426 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
15427 if(!isWasmInitialized) {
15428 throw new Error("initializeWasm() must be awaited first!");
15430 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
15431 return nativeResponseValue;
15433 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
15435 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
15436 if(!isWasmInitialized) {
15437 throw new Error("initializeWasm() must be awaited first!");
15439 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
15440 return nativeResponseValue;
15442 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
15444 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
15445 if(!isWasmInitialized) {
15446 throw new Error("initializeWasm() must be awaited first!");
15448 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
15449 return nativeResponseValue;
15451 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
15453 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
15454 if(!isWasmInitialized) {
15455 throw new Error("initializeWasm() must be awaited first!");
15457 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
15458 // debug statements here
15460 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
15462 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15463 if(!isWasmInitialized) {
15464 throw new Error("initializeWasm() must be awaited first!");
15466 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
15467 return nativeResponseValue;
15469 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
15471 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
15472 if(!isWasmInitialized) {
15473 throw new Error("initializeWasm() must be awaited first!");
15475 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
15476 return nativeResponseValue;
15478 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
15480 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
15481 if(!isWasmInitialized) {
15482 throw new Error("initializeWasm() must be awaited first!");
15484 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
15485 return nativeResponseValue;
15487 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
15489 export function CResult_InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
15490 if(!isWasmInitialized) {
15491 throw new Error("initializeWasm() must be awaited first!");
15493 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
15494 return nativeResponseValue;
15496 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
15498 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
15499 if(!isWasmInitialized) {
15500 throw new Error("initializeWasm() must be awaited first!");
15502 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
15503 return nativeResponseValue;
15505 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
15507 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
15508 if(!isWasmInitialized) {
15509 throw new Error("initializeWasm() must be awaited first!");
15511 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
15512 // debug statements here
15514 // uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
15516 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
15517 if(!isWasmInitialized) {
15518 throw new Error("initializeWasm() must be awaited first!");
15520 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
15521 return nativeResponseValue;
15523 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
15525 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
15526 if(!isWasmInitialized) {
15527 throw new Error("initializeWasm() must be awaited first!");
15529 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
15530 return nativeResponseValue;
15532 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
15534 export function COption_FilterZ_some(o: bigint): bigint {
15535 if(!isWasmInitialized) {
15536 throw new Error("initializeWasm() must be awaited first!");
15538 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
15539 return nativeResponseValue;
15541 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
15543 export function COption_FilterZ_none(): bigint {
15544 if(!isWasmInitialized) {
15545 throw new Error("initializeWasm() must be awaited first!");
15547 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
15548 return nativeResponseValue;
15550 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
15552 export function COption_FilterZ_free(_res: bigint): void {
15553 if(!isWasmInitialized) {
15554 throw new Error("initializeWasm() must be awaited first!");
15556 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
15557 // debug statements here
15559 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
15561 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
15562 if(!isWasmInitialized) {
15563 throw new Error("initializeWasm() must be awaited first!");
15565 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
15566 return nativeResponseValue;
15568 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
15570 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
15571 if(!isWasmInitialized) {
15572 throw new Error("initializeWasm() must be awaited first!");
15574 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15575 return nativeResponseValue;
15577 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15579 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
15580 if(!isWasmInitialized) {
15581 throw new Error("initializeWasm() must be awaited first!");
15583 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15584 return nativeResponseValue;
15586 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15588 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
15589 if(!isWasmInitialized) {
15590 throw new Error("initializeWasm() must be awaited first!");
15592 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15593 // debug statements here
15595 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15597 export function CVec_OutPointZ_free(_res: number): void {
15598 if(!isWasmInitialized) {
15599 throw new Error("initializeWasm() must be awaited first!");
15601 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15602 // debug statements here
15604 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15606 export function PaymentPurpose_free(this_ptr: bigint): void {
15607 if(!isWasmInitialized) {
15608 throw new Error("initializeWasm() must be awaited first!");
15610 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15611 // debug statements here
15613 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15615 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
15616 if(!isWasmInitialized) {
15617 throw new Error("initializeWasm() must be awaited first!");
15619 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15620 return nativeResponseValue;
15622 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15624 export function PaymentPurpose_clone(orig: bigint): bigint {
15625 if(!isWasmInitialized) {
15626 throw new Error("initializeWasm() must be awaited first!");
15628 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15629 return nativeResponseValue;
15631 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15633 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): bigint {
15634 if(!isWasmInitialized) {
15635 throw new Error("initializeWasm() must be awaited first!");
15637 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15638 return nativeResponseValue;
15640 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15642 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
15643 if(!isWasmInitialized) {
15644 throw new Error("initializeWasm() must be awaited first!");
15646 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15647 return nativeResponseValue;
15649 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15651 export function PaymentPurpose_write(obj: bigint): number {
15652 if(!isWasmInitialized) {
15653 throw new Error("initializeWasm() must be awaited first!");
15655 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15656 return nativeResponseValue;
15658 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15660 export function PaymentPurpose_read(ser: number): bigint {
15661 if(!isWasmInitialized) {
15662 throw new Error("initializeWasm() must be awaited first!");
15664 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15665 return nativeResponseValue;
15667 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15669 export function ClosureReason_free(this_ptr: bigint): void {
15670 if(!isWasmInitialized) {
15671 throw new Error("initializeWasm() must be awaited first!");
15673 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15674 // debug statements here
15676 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15678 export function ClosureReason_clone_ptr(arg: bigint): bigint {
15679 if(!isWasmInitialized) {
15680 throw new Error("initializeWasm() must be awaited first!");
15682 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15683 return nativeResponseValue;
15685 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15687 export function ClosureReason_clone(orig: bigint): bigint {
15688 if(!isWasmInitialized) {
15689 throw new Error("initializeWasm() must be awaited first!");
15691 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15692 return nativeResponseValue;
15694 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15696 export function ClosureReason_counterparty_force_closed(peer_msg: number): bigint {
15697 if(!isWasmInitialized) {
15698 throw new Error("initializeWasm() must be awaited first!");
15700 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15701 return nativeResponseValue;
15703 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15705 export function ClosureReason_holder_force_closed(): bigint {
15706 if(!isWasmInitialized) {
15707 throw new Error("initializeWasm() must be awaited first!");
15709 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15710 return nativeResponseValue;
15712 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15714 export function ClosureReason_cooperative_closure(): bigint {
15715 if(!isWasmInitialized) {
15716 throw new Error("initializeWasm() must be awaited first!");
15718 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15719 return nativeResponseValue;
15721 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15723 export function ClosureReason_commitment_tx_confirmed(): bigint {
15724 if(!isWasmInitialized) {
15725 throw new Error("initializeWasm() must be awaited first!");
15727 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15728 return nativeResponseValue;
15730 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15732 export function ClosureReason_funding_timed_out(): bigint {
15733 if(!isWasmInitialized) {
15734 throw new Error("initializeWasm() must be awaited first!");
15736 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15737 return nativeResponseValue;
15739 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15741 export function ClosureReason_processing_error(err: number): bigint {
15742 if(!isWasmInitialized) {
15743 throw new Error("initializeWasm() must be awaited first!");
15745 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15746 return nativeResponseValue;
15748 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15750 export function ClosureReason_disconnected_peer(): bigint {
15751 if(!isWasmInitialized) {
15752 throw new Error("initializeWasm() must be awaited first!");
15754 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15755 return nativeResponseValue;
15757 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15759 export function ClosureReason_outdated_channel_manager(): bigint {
15760 if(!isWasmInitialized) {
15761 throw new Error("initializeWasm() must be awaited first!");
15763 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15764 return nativeResponseValue;
15766 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15768 export function ClosureReason_write(obj: bigint): number {
15769 if(!isWasmInitialized) {
15770 throw new Error("initializeWasm() must be awaited first!");
15772 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15773 return nativeResponseValue;
15775 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15777 export function ClosureReason_read(ser: number): bigint {
15778 if(!isWasmInitialized) {
15779 throw new Error("initializeWasm() must be awaited first!");
15781 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15782 return nativeResponseValue;
15784 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
15786 export function HTLCDestination_free(this_ptr: bigint): void {
15787 if(!isWasmInitialized) {
15788 throw new Error("initializeWasm() must be awaited first!");
15790 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
15791 // debug statements here
15793 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
15795 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
15796 if(!isWasmInitialized) {
15797 throw new Error("initializeWasm() must be awaited first!");
15799 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
15800 return nativeResponseValue;
15802 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
15804 export function HTLCDestination_clone(orig: bigint): bigint {
15805 if(!isWasmInitialized) {
15806 throw new Error("initializeWasm() must be awaited first!");
15808 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
15809 return nativeResponseValue;
15811 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
15813 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
15814 if(!isWasmInitialized) {
15815 throw new Error("initializeWasm() must be awaited first!");
15817 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
15818 return nativeResponseValue;
15820 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
15822 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
15823 if(!isWasmInitialized) {
15824 throw new Error("initializeWasm() must be awaited first!");
15826 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
15827 return nativeResponseValue;
15829 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
15831 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
15832 if(!isWasmInitialized) {
15833 throw new Error("initializeWasm() must be awaited first!");
15835 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
15836 return nativeResponseValue;
15838 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
15840 export function HTLCDestination_write(obj: bigint): number {
15841 if(!isWasmInitialized) {
15842 throw new Error("initializeWasm() must be awaited first!");
15844 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
15845 return nativeResponseValue;
15847 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
15849 export function HTLCDestination_read(ser: number): bigint {
15850 if(!isWasmInitialized) {
15851 throw new Error("initializeWasm() must be awaited first!");
15853 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
15854 return nativeResponseValue;
15856 // void Event_free(struct LDKEvent this_ptr);
15858 export function Event_free(this_ptr: bigint): void {
15859 if(!isWasmInitialized) {
15860 throw new Error("initializeWasm() must be awaited first!");
15862 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15863 // debug statements here
15865 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15867 export function Event_clone_ptr(arg: bigint): bigint {
15868 if(!isWasmInitialized) {
15869 throw new Error("initializeWasm() must be awaited first!");
15871 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15872 return nativeResponseValue;
15874 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15876 export function Event_clone(orig: bigint): bigint {
15877 if(!isWasmInitialized) {
15878 throw new Error("initializeWasm() must be awaited first!");
15880 const nativeResponseValue = wasm.TS_Event_clone(orig);
15881 return nativeResponseValue;
15883 // struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, uint64_t user_channel_id);
15885 export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): bigint {
15886 if(!isWasmInitialized) {
15887 throw new Error("initializeWasm() must be awaited first!");
15889 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15890 return nativeResponseValue;
15892 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15894 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
15895 if(!isWasmInitialized) {
15896 throw new Error("initializeWasm() must be awaited first!");
15898 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15899 return nativeResponseValue;
15901 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15903 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: bigint): bigint {
15904 if(!isWasmInitialized) {
15905 throw new Error("initializeWasm() must be awaited first!");
15907 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15908 return nativeResponseValue;
15910 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15912 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
15913 if(!isWasmInitialized) {
15914 throw new Error("initializeWasm() must be awaited first!");
15916 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15917 return nativeResponseValue;
15919 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15921 export function Event_payment_failed(payment_id: number, payment_hash: number): bigint {
15922 if(!isWasmInitialized) {
15923 throw new Error("initializeWasm() must be awaited first!");
15925 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15926 return nativeResponseValue;
15928 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15930 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): bigint {
15931 if(!isWasmInitialized) {
15932 throw new Error("initializeWasm() must be awaited first!");
15934 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15935 return nativeResponseValue;
15937 // struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool rejected_by_dest, struct LDKCOption_NetworkUpdateZ network_update, bool all_paths_failed, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id, struct LDKRouteParameters retry);
15939 export function Event_payment_path_failed(payment_id: number, payment_hash: number, rejected_by_dest: boolean, network_update: bigint, all_paths_failed: boolean, path: number, short_channel_id: bigint, retry: bigint): bigint {
15940 if(!isWasmInitialized) {
15941 throw new Error("initializeWasm() must be awaited first!");
15943 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, rejected_by_dest, network_update, all_paths_failed, path, short_channel_id, retry);
15944 return nativeResponseValue;
15946 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15948 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): bigint {
15949 if(!isWasmInitialized) {
15950 throw new Error("initializeWasm() must be awaited first!");
15952 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
15953 return nativeResponseValue;
15955 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
15957 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: bigint): bigint {
15958 if(!isWasmInitialized) {
15959 throw new Error("initializeWasm() must be awaited first!");
15961 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
15962 return nativeResponseValue;
15964 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15966 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
15967 if(!isWasmInitialized) {
15968 throw new Error("initializeWasm() must be awaited first!");
15970 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15971 return nativeResponseValue;
15973 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15975 export function Event_spendable_outputs(outputs: number): bigint {
15976 if(!isWasmInitialized) {
15977 throw new Error("initializeWasm() must be awaited first!");
15979 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15980 return nativeResponseValue;
15982 // struct LDKEvent Event_payment_forwarded(struct LDKThirtyTwoBytes prev_channel_id, struct LDKThirtyTwoBytes next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
15984 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: bigint, claim_from_onchain_tx: boolean): bigint {
15985 if(!isWasmInitialized) {
15986 throw new Error("initializeWasm() must be awaited first!");
15988 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15989 return nativeResponseValue;
15991 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15993 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: bigint): bigint {
15994 if(!isWasmInitialized) {
15995 throw new Error("initializeWasm() must be awaited first!");
15997 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15998 return nativeResponseValue;
16000 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
16002 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
16003 if(!isWasmInitialized) {
16004 throw new Error("initializeWasm() must be awaited first!");
16006 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
16007 return nativeResponseValue;
16009 // 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);
16011 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
16012 if(!isWasmInitialized) {
16013 throw new Error("initializeWasm() must be awaited first!");
16015 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
16016 return nativeResponseValue;
16018 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
16020 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
16021 if(!isWasmInitialized) {
16022 throw new Error("initializeWasm() must be awaited first!");
16024 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
16025 return nativeResponseValue;
16027 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
16029 export function Event_write(obj: bigint): number {
16030 if(!isWasmInitialized) {
16031 throw new Error("initializeWasm() must be awaited first!");
16033 const nativeResponseValue = wasm.TS_Event_write(obj);
16034 return nativeResponseValue;
16036 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
16038 export function Event_read(ser: number): bigint {
16039 if(!isWasmInitialized) {
16040 throw new Error("initializeWasm() must be awaited first!");
16042 const nativeResponseValue = wasm.TS_Event_read(ser);
16043 return nativeResponseValue;
16045 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
16047 export function MessageSendEvent_free(this_ptr: bigint): void {
16048 if(!isWasmInitialized) {
16049 throw new Error("initializeWasm() must be awaited first!");
16051 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
16052 // debug statements here
16054 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
16056 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
16057 if(!isWasmInitialized) {
16058 throw new Error("initializeWasm() must be awaited first!");
16060 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
16061 return nativeResponseValue;
16063 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
16065 export function MessageSendEvent_clone(orig: bigint): bigint {
16066 if(!isWasmInitialized) {
16067 throw new Error("initializeWasm() must be awaited first!");
16069 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
16070 return nativeResponseValue;
16072 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
16074 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
16075 if(!isWasmInitialized) {
16076 throw new Error("initializeWasm() must be awaited first!");
16078 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
16079 return nativeResponseValue;
16081 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
16083 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
16084 if(!isWasmInitialized) {
16085 throw new Error("initializeWasm() must be awaited first!");
16087 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
16088 return nativeResponseValue;
16090 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
16092 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
16093 if(!isWasmInitialized) {
16094 throw new Error("initializeWasm() must be awaited first!");
16096 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
16097 return nativeResponseValue;
16099 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
16101 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
16102 if(!isWasmInitialized) {
16103 throw new Error("initializeWasm() must be awaited first!");
16105 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
16106 return nativeResponseValue;
16108 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
16110 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
16111 if(!isWasmInitialized) {
16112 throw new Error("initializeWasm() must be awaited first!");
16114 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
16115 return nativeResponseValue;
16117 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
16119 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
16120 if(!isWasmInitialized) {
16121 throw new Error("initializeWasm() must be awaited first!");
16123 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
16124 return nativeResponseValue;
16126 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
16128 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
16129 if(!isWasmInitialized) {
16130 throw new Error("initializeWasm() must be awaited first!");
16132 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
16133 return nativeResponseValue;
16135 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
16137 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
16138 if(!isWasmInitialized) {
16139 throw new Error("initializeWasm() must be awaited first!");
16141 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
16142 return nativeResponseValue;
16144 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
16146 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
16147 if(!isWasmInitialized) {
16148 throw new Error("initializeWasm() must be awaited first!");
16150 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
16151 return nativeResponseValue;
16153 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
16155 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
16156 if(!isWasmInitialized) {
16157 throw new Error("initializeWasm() must be awaited first!");
16159 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
16160 return nativeResponseValue;
16162 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
16164 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
16165 if(!isWasmInitialized) {
16166 throw new Error("initializeWasm() must be awaited first!");
16168 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
16169 return nativeResponseValue;
16171 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
16173 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
16174 if(!isWasmInitialized) {
16175 throw new Error("initializeWasm() must be awaited first!");
16177 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
16178 return nativeResponseValue;
16180 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
16182 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
16183 if(!isWasmInitialized) {
16184 throw new Error("initializeWasm() must be awaited first!");
16186 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
16187 return nativeResponseValue;
16189 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
16191 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
16192 if(!isWasmInitialized) {
16193 throw new Error("initializeWasm() must be awaited first!");
16195 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
16196 return nativeResponseValue;
16198 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
16200 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
16201 if(!isWasmInitialized) {
16202 throw new Error("initializeWasm() must be awaited first!");
16204 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
16205 return nativeResponseValue;
16207 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
16209 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
16210 if(!isWasmInitialized) {
16211 throw new Error("initializeWasm() must be awaited first!");
16213 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
16214 return nativeResponseValue;
16216 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
16218 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
16219 if(!isWasmInitialized) {
16220 throw new Error("initializeWasm() must be awaited first!");
16222 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
16223 return nativeResponseValue;
16225 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
16227 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
16228 if(!isWasmInitialized) {
16229 throw new Error("initializeWasm() must be awaited first!");
16231 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
16232 return nativeResponseValue;
16234 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
16236 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
16237 if(!isWasmInitialized) {
16238 throw new Error("initializeWasm() must be awaited first!");
16240 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
16241 return nativeResponseValue;
16243 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
16245 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
16246 if(!isWasmInitialized) {
16247 throw new Error("initializeWasm() must be awaited first!");
16249 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
16250 return nativeResponseValue;
16252 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
16254 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
16255 if(!isWasmInitialized) {
16256 throw new Error("initializeWasm() must be awaited first!");
16258 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
16259 // debug statements here
16261 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
16263 export function EventsProvider_free(this_ptr: bigint): void {
16264 if(!isWasmInitialized) {
16265 throw new Error("initializeWasm() must be awaited first!");
16267 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
16268 // debug statements here
16270 // void EventHandler_free(struct LDKEventHandler this_ptr);
16272 export function EventHandler_free(this_ptr: bigint): void {
16273 if(!isWasmInitialized) {
16274 throw new Error("initializeWasm() must be awaited first!");
16276 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
16277 // debug statements here
16279 // void APIError_free(struct LDKAPIError this_ptr);
16281 export function APIError_free(this_ptr: bigint): void {
16282 if(!isWasmInitialized) {
16283 throw new Error("initializeWasm() must be awaited first!");
16285 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
16286 // debug statements here
16288 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
16290 export function APIError_clone_ptr(arg: bigint): bigint {
16291 if(!isWasmInitialized) {
16292 throw new Error("initializeWasm() must be awaited first!");
16294 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
16295 return nativeResponseValue;
16297 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
16299 export function APIError_clone(orig: bigint): bigint {
16300 if(!isWasmInitialized) {
16301 throw new Error("initializeWasm() must be awaited first!");
16303 const nativeResponseValue = wasm.TS_APIError_clone(orig);
16304 return nativeResponseValue;
16306 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
16308 export function APIError_apimisuse_error(err: number): bigint {
16309 if(!isWasmInitialized) {
16310 throw new Error("initializeWasm() must be awaited first!");
16312 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
16313 return nativeResponseValue;
16315 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
16317 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
16318 if(!isWasmInitialized) {
16319 throw new Error("initializeWasm() must be awaited first!");
16321 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
16322 return nativeResponseValue;
16324 // struct LDKAPIError APIError_route_error(struct LDKStr err);
16326 export function APIError_route_error(err: number): bigint {
16327 if(!isWasmInitialized) {
16328 throw new Error("initializeWasm() must be awaited first!");
16330 const nativeResponseValue = wasm.TS_APIError_route_error(err);
16331 return nativeResponseValue;
16333 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
16335 export function APIError_channel_unavailable(err: number): bigint {
16336 if(!isWasmInitialized) {
16337 throw new Error("initializeWasm() must be awaited first!");
16339 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
16340 return nativeResponseValue;
16342 // struct LDKAPIError APIError_monitor_update_failed(void);
16344 export function APIError_monitor_update_failed(): bigint {
16345 if(!isWasmInitialized) {
16346 throw new Error("initializeWasm() must be awaited first!");
16348 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
16349 return nativeResponseValue;
16351 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
16353 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
16354 if(!isWasmInitialized) {
16355 throw new Error("initializeWasm() must be awaited first!");
16357 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
16358 return nativeResponseValue;
16360 // void BigSize_free(struct LDKBigSize this_obj);
16362 export function BigSize_free(this_obj: bigint): void {
16363 if(!isWasmInitialized) {
16364 throw new Error("initializeWasm() must be awaited first!");
16366 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
16367 // debug statements here
16369 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
16371 export function BigSize_get_a(this_ptr: bigint): bigint {
16372 if(!isWasmInitialized) {
16373 throw new Error("initializeWasm() must be awaited first!");
16375 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
16376 return nativeResponseValue;
16378 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
16380 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
16381 if(!isWasmInitialized) {
16382 throw new Error("initializeWasm() must be awaited first!");
16384 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
16385 // debug statements here
16387 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
16389 export function BigSize_new(a_arg: bigint): bigint {
16390 if(!isWasmInitialized) {
16391 throw new Error("initializeWasm() must be awaited first!");
16393 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
16394 return nativeResponseValue;
16396 // void Hostname_free(struct LDKHostname this_obj);
16398 export function Hostname_free(this_obj: bigint): void {
16399 if(!isWasmInitialized) {
16400 throw new Error("initializeWasm() must be awaited first!");
16402 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
16403 // debug statements here
16405 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
16407 export function Hostname_clone_ptr(arg: bigint): bigint {
16408 if(!isWasmInitialized) {
16409 throw new Error("initializeWasm() must be awaited first!");
16411 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
16412 return nativeResponseValue;
16414 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
16416 export function Hostname_clone(orig: bigint): bigint {
16417 if(!isWasmInitialized) {
16418 throw new Error("initializeWasm() must be awaited first!");
16420 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
16421 return nativeResponseValue;
16423 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
16425 export function Hostname_len(this_arg: bigint): number {
16426 if(!isWasmInitialized) {
16427 throw new Error("initializeWasm() must be awaited first!");
16429 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
16430 return nativeResponseValue;
16432 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
16434 export function sign(msg: number, sk: number): bigint {
16435 if(!isWasmInitialized) {
16436 throw new Error("initializeWasm() must be awaited first!");
16438 const nativeResponseValue = wasm.TS_sign(msg, sk);
16439 return nativeResponseValue;
16441 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
16443 export function recover_pk(msg: number, sig: number): bigint {
16444 if(!isWasmInitialized) {
16445 throw new Error("initializeWasm() must be awaited first!");
16447 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
16448 return nativeResponseValue;
16450 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
16452 export function verify(msg: number, sig: number, pk: number): boolean {
16453 if(!isWasmInitialized) {
16454 throw new Error("initializeWasm() must be awaited first!");
16456 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
16457 return nativeResponseValue;
16459 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
16461 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
16462 if(!isWasmInitialized) {
16463 throw new Error("initializeWasm() must be awaited first!");
16465 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
16466 return nativeResponseValue;
16468 // void Persister_free(struct LDKPersister this_ptr);
16470 export function Persister_free(this_ptr: bigint): void {
16471 if(!isWasmInitialized) {
16472 throw new Error("initializeWasm() must be awaited first!");
16474 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
16475 // debug statements here
16477 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
16479 export function Level_clone(orig: bigint): Level {
16480 if(!isWasmInitialized) {
16481 throw new Error("initializeWasm() must be awaited first!");
16483 const nativeResponseValue = wasm.TS_Level_clone(orig);
16484 return nativeResponseValue;
16486 // enum LDKLevel Level_gossip(void);
16488 export function Level_gossip(): Level {
16489 if(!isWasmInitialized) {
16490 throw new Error("initializeWasm() must be awaited first!");
16492 const nativeResponseValue = wasm.TS_Level_gossip();
16493 return nativeResponseValue;
16495 // enum LDKLevel Level_trace(void);
16497 export function Level_trace(): Level {
16498 if(!isWasmInitialized) {
16499 throw new Error("initializeWasm() must be awaited first!");
16501 const nativeResponseValue = wasm.TS_Level_trace();
16502 return nativeResponseValue;
16504 // enum LDKLevel Level_debug(void);
16506 export function Level_debug(): Level {
16507 if(!isWasmInitialized) {
16508 throw new Error("initializeWasm() must be awaited first!");
16510 const nativeResponseValue = wasm.TS_Level_debug();
16511 return nativeResponseValue;
16513 // enum LDKLevel Level_info(void);
16515 export function Level_info(): Level {
16516 if(!isWasmInitialized) {
16517 throw new Error("initializeWasm() must be awaited first!");
16519 const nativeResponseValue = wasm.TS_Level_info();
16520 return nativeResponseValue;
16522 // enum LDKLevel Level_warn(void);
16524 export function Level_warn(): Level {
16525 if(!isWasmInitialized) {
16526 throw new Error("initializeWasm() must be awaited first!");
16528 const nativeResponseValue = wasm.TS_Level_warn();
16529 return nativeResponseValue;
16531 // enum LDKLevel Level_error(void);
16533 export function Level_error(): Level {
16534 if(!isWasmInitialized) {
16535 throw new Error("initializeWasm() must be awaited first!");
16537 const nativeResponseValue = wasm.TS_Level_error();
16538 return nativeResponseValue;
16540 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
16542 export function Level_eq(a: bigint, b: bigint): boolean {
16543 if(!isWasmInitialized) {
16544 throw new Error("initializeWasm() must be awaited first!");
16546 const nativeResponseValue = wasm.TS_Level_eq(a, b);
16547 return nativeResponseValue;
16549 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
16551 export function Level_hash(o: bigint): bigint {
16552 if(!isWasmInitialized) {
16553 throw new Error("initializeWasm() must be awaited first!");
16555 const nativeResponseValue = wasm.TS_Level_hash(o);
16556 return nativeResponseValue;
16558 // MUST_USE_RES enum LDKLevel Level_max(void);
16560 export function Level_max(): Level {
16561 if(!isWasmInitialized) {
16562 throw new Error("initializeWasm() must be awaited first!");
16564 const nativeResponseValue = wasm.TS_Level_max();
16565 return nativeResponseValue;
16567 // void Record_free(struct LDKRecord this_obj);
16569 export function Record_free(this_obj: bigint): void {
16570 if(!isWasmInitialized) {
16571 throw new Error("initializeWasm() must be awaited first!");
16573 const nativeResponseValue = wasm.TS_Record_free(this_obj);
16574 // debug statements here
16576 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
16578 export function Record_get_level(this_ptr: bigint): Level {
16579 if(!isWasmInitialized) {
16580 throw new Error("initializeWasm() must be awaited first!");
16582 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
16583 return nativeResponseValue;
16585 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
16587 export function Record_set_level(this_ptr: bigint, val: Level): void {
16588 if(!isWasmInitialized) {
16589 throw new Error("initializeWasm() must be awaited first!");
16591 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
16592 // debug statements here
16594 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
16596 export function Record_get_args(this_ptr: bigint): number {
16597 if(!isWasmInitialized) {
16598 throw new Error("initializeWasm() must be awaited first!");
16600 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
16601 return nativeResponseValue;
16603 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16605 export function Record_set_args(this_ptr: bigint, val: number): void {
16606 if(!isWasmInitialized) {
16607 throw new Error("initializeWasm() must be awaited first!");
16609 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
16610 // debug statements here
16612 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
16614 export function Record_get_module_path(this_ptr: bigint): number {
16615 if(!isWasmInitialized) {
16616 throw new Error("initializeWasm() must be awaited first!");
16618 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
16619 return nativeResponseValue;
16621 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16623 export function Record_set_module_path(this_ptr: bigint, val: number): void {
16624 if(!isWasmInitialized) {
16625 throw new Error("initializeWasm() must be awaited first!");
16627 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
16628 // debug statements here
16630 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
16632 export function Record_get_file(this_ptr: bigint): number {
16633 if(!isWasmInitialized) {
16634 throw new Error("initializeWasm() must be awaited first!");
16636 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
16637 return nativeResponseValue;
16639 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16641 export function Record_set_file(this_ptr: bigint, val: number): void {
16642 if(!isWasmInitialized) {
16643 throw new Error("initializeWasm() must be awaited first!");
16645 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
16646 // debug statements here
16648 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
16650 export function Record_get_line(this_ptr: bigint): number {
16651 if(!isWasmInitialized) {
16652 throw new Error("initializeWasm() must be awaited first!");
16654 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
16655 return nativeResponseValue;
16657 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
16659 export function Record_set_line(this_ptr: bigint, val: number): void {
16660 if(!isWasmInitialized) {
16661 throw new Error("initializeWasm() must be awaited first!");
16663 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
16664 // debug statements here
16666 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
16668 export function Record_clone_ptr(arg: bigint): bigint {
16669 if(!isWasmInitialized) {
16670 throw new Error("initializeWasm() must be awaited first!");
16672 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
16673 return nativeResponseValue;
16675 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
16677 export function Record_clone(orig: bigint): bigint {
16678 if(!isWasmInitialized) {
16679 throw new Error("initializeWasm() must be awaited first!");
16681 const nativeResponseValue = wasm.TS_Record_clone(orig);
16682 return nativeResponseValue;
16684 // void Logger_free(struct LDKLogger this_ptr);
16686 export function Logger_free(this_ptr: bigint): void {
16687 if(!isWasmInitialized) {
16688 throw new Error("initializeWasm() must be awaited first!");
16690 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
16691 // debug statements here
16693 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
16695 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
16696 if(!isWasmInitialized) {
16697 throw new Error("initializeWasm() must be awaited first!");
16699 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
16700 // debug statements here
16702 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16704 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
16705 if(!isWasmInitialized) {
16706 throw new Error("initializeWasm() must be awaited first!");
16708 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16709 return nativeResponseValue;
16711 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16713 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
16714 if(!isWasmInitialized) {
16715 throw new Error("initializeWasm() must be awaited first!");
16717 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16718 // debug statements here
16720 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16722 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
16723 if(!isWasmInitialized) {
16724 throw new Error("initializeWasm() must be awaited first!");
16726 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16727 return nativeResponseValue;
16729 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16731 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
16732 if(!isWasmInitialized) {
16733 throw new Error("initializeWasm() must be awaited first!");
16735 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16736 // debug statements here
16738 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16740 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
16741 if(!isWasmInitialized) {
16742 throw new Error("initializeWasm() must be awaited first!");
16744 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16745 return nativeResponseValue;
16747 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16749 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
16750 if(!isWasmInitialized) {
16751 throw new Error("initializeWasm() must be awaited first!");
16753 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16754 // debug statements here
16756 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16758 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
16759 if(!isWasmInitialized) {
16760 throw new Error("initializeWasm() must be awaited first!");
16762 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16763 return nativeResponseValue;
16765 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16767 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
16768 if(!isWasmInitialized) {
16769 throw new Error("initializeWasm() must be awaited first!");
16771 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16772 // debug statements here
16774 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16776 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
16777 if(!isWasmInitialized) {
16778 throw new Error("initializeWasm() must be awaited first!");
16780 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16781 return nativeResponseValue;
16783 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16785 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
16786 if(!isWasmInitialized) {
16787 throw new Error("initializeWasm() must be awaited first!");
16789 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16790 // debug statements here
16792 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16794 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
16795 if(!isWasmInitialized) {
16796 throw new Error("initializeWasm() must be awaited first!");
16798 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
16799 return nativeResponseValue;
16801 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16803 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
16804 if(!isWasmInitialized) {
16805 throw new Error("initializeWasm() must be awaited first!");
16807 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
16808 // debug statements here
16810 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16812 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
16813 if(!isWasmInitialized) {
16814 throw new Error("initializeWasm() must be awaited first!");
16816 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16817 return nativeResponseValue;
16819 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16821 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
16822 if(!isWasmInitialized) {
16823 throw new Error("initializeWasm() must be awaited first!");
16825 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16826 // debug statements here
16828 // 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);
16830 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): bigint {
16831 if(!isWasmInitialized) {
16832 throw new Error("initializeWasm() must be awaited first!");
16834 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);
16835 return nativeResponseValue;
16837 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16839 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
16840 if(!isWasmInitialized) {
16841 throw new Error("initializeWasm() must be awaited first!");
16843 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16844 return nativeResponseValue;
16846 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16848 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
16849 if(!isWasmInitialized) {
16850 throw new Error("initializeWasm() must be awaited first!");
16852 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16853 return nativeResponseValue;
16855 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16857 export function ChannelHandshakeConfig_default(): bigint {
16858 if(!isWasmInitialized) {
16859 throw new Error("initializeWasm() must be awaited first!");
16861 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16862 return nativeResponseValue;
16864 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16866 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
16867 if(!isWasmInitialized) {
16868 throw new Error("initializeWasm() must be awaited first!");
16870 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16871 // debug statements here
16873 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16875 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
16876 if(!isWasmInitialized) {
16877 throw new Error("initializeWasm() must be awaited first!");
16879 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16880 return nativeResponseValue;
16882 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16884 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
16885 if(!isWasmInitialized) {
16886 throw new Error("initializeWasm() must be awaited first!");
16888 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16889 // debug statements here
16891 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16893 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
16894 if(!isWasmInitialized) {
16895 throw new Error("initializeWasm() must be awaited first!");
16897 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16898 return nativeResponseValue;
16900 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16902 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
16903 if(!isWasmInitialized) {
16904 throw new Error("initializeWasm() must be awaited first!");
16906 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16907 // debug statements here
16909 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16911 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
16912 if(!isWasmInitialized) {
16913 throw new Error("initializeWasm() must be awaited first!");
16915 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16916 return nativeResponseValue;
16918 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16920 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
16921 if(!isWasmInitialized) {
16922 throw new Error("initializeWasm() must be awaited first!");
16924 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16925 // debug statements here
16927 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16929 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
16930 if(!isWasmInitialized) {
16931 throw new Error("initializeWasm() must be awaited first!");
16933 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16934 return nativeResponseValue;
16936 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16938 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
16939 if(!isWasmInitialized) {
16940 throw new Error("initializeWasm() must be awaited first!");
16942 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16943 // debug statements here
16945 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16947 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
16948 if(!isWasmInitialized) {
16949 throw new Error("initializeWasm() must be awaited first!");
16951 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16952 return nativeResponseValue;
16954 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16956 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
16957 if(!isWasmInitialized) {
16958 throw new Error("initializeWasm() must be awaited first!");
16960 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16961 // debug statements here
16963 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16965 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
16966 if(!isWasmInitialized) {
16967 throw new Error("initializeWasm() must be awaited first!");
16969 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16970 return nativeResponseValue;
16972 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16974 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
16975 if(!isWasmInitialized) {
16976 throw new Error("initializeWasm() must be awaited first!");
16978 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16979 // debug statements here
16981 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16983 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
16984 if(!isWasmInitialized) {
16985 throw new Error("initializeWasm() must be awaited first!");
16987 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16988 return nativeResponseValue;
16990 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16992 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
16993 if(!isWasmInitialized) {
16994 throw new Error("initializeWasm() must be awaited first!");
16996 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16997 // debug statements here
16999 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17001 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
17002 if(!isWasmInitialized) {
17003 throw new Error("initializeWasm() must be awaited first!");
17005 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
17006 return nativeResponseValue;
17008 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17010 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
17011 if(!isWasmInitialized) {
17012 throw new Error("initializeWasm() must be awaited first!");
17014 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
17015 // debug statements here
17017 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17019 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
17020 if(!isWasmInitialized) {
17021 throw new Error("initializeWasm() must be awaited first!");
17023 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
17024 return nativeResponseValue;
17026 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17028 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
17029 if(!isWasmInitialized) {
17030 throw new Error("initializeWasm() must be awaited first!");
17032 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
17033 // debug statements here
17035 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17037 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
17038 if(!isWasmInitialized) {
17039 throw new Error("initializeWasm() must be awaited first!");
17041 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
17042 return nativeResponseValue;
17044 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
17046 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
17047 if(!isWasmInitialized) {
17048 throw new Error("initializeWasm() must be awaited first!");
17050 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
17051 // debug statements here
17053 // 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);
17055 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 {
17056 if(!isWasmInitialized) {
17057 throw new Error("initializeWasm() must be awaited first!");
17059 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);
17060 return nativeResponseValue;
17062 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
17064 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
17065 if(!isWasmInitialized) {
17066 throw new Error("initializeWasm() must be awaited first!");
17068 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
17069 return nativeResponseValue;
17071 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
17073 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
17074 if(!isWasmInitialized) {
17075 throw new Error("initializeWasm() must be awaited first!");
17077 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
17078 return nativeResponseValue;
17080 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
17082 export function ChannelHandshakeLimits_default(): bigint {
17083 if(!isWasmInitialized) {
17084 throw new Error("initializeWasm() must be awaited first!");
17086 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
17087 return nativeResponseValue;
17089 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
17091 export function ChannelConfig_free(this_obj: bigint): void {
17092 if(!isWasmInitialized) {
17093 throw new Error("initializeWasm() must be awaited first!");
17095 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
17096 // debug statements here
17098 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17100 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
17101 if(!isWasmInitialized) {
17102 throw new Error("initializeWasm() must be awaited first!");
17104 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
17105 return nativeResponseValue;
17107 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
17109 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
17110 if(!isWasmInitialized) {
17111 throw new Error("initializeWasm() must be awaited first!");
17113 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
17114 // debug statements here
17116 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17118 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
17119 if(!isWasmInitialized) {
17120 throw new Error("initializeWasm() must be awaited first!");
17122 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
17123 return nativeResponseValue;
17125 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
17127 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
17128 if(!isWasmInitialized) {
17129 throw new Error("initializeWasm() must be awaited first!");
17131 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
17132 // debug statements here
17134 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17136 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
17137 if(!isWasmInitialized) {
17138 throw new Error("initializeWasm() must be awaited first!");
17140 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
17141 return nativeResponseValue;
17143 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
17145 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
17146 if(!isWasmInitialized) {
17147 throw new Error("initializeWasm() must be awaited first!");
17149 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
17150 // debug statements here
17152 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17154 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
17155 if(!isWasmInitialized) {
17156 throw new Error("initializeWasm() must be awaited first!");
17158 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
17159 return nativeResponseValue;
17161 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
17163 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
17164 if(!isWasmInitialized) {
17165 throw new Error("initializeWasm() must be awaited first!");
17167 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
17168 // debug statements here
17170 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17172 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
17173 if(!isWasmInitialized) {
17174 throw new Error("initializeWasm() must be awaited first!");
17176 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
17177 return nativeResponseValue;
17179 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
17181 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
17182 if(!isWasmInitialized) {
17183 throw new Error("initializeWasm() must be awaited first!");
17185 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
17186 // debug statements here
17188 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t forwarding_fee_proportional_millionths_arg, uint32_t forwarding_fee_base_msat_arg, uint16_t cltv_expiry_delta_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
17190 export function ChannelConfig_new(forwarding_fee_proportional_millionths_arg: number, forwarding_fee_base_msat_arg: number, cltv_expiry_delta_arg: number, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): bigint {
17191 if(!isWasmInitialized) {
17192 throw new Error("initializeWasm() must be awaited first!");
17194 const nativeResponseValue = wasm.TS_ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
17195 return nativeResponseValue;
17197 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
17199 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
17200 if(!isWasmInitialized) {
17201 throw new Error("initializeWasm() must be awaited first!");
17203 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
17204 return nativeResponseValue;
17206 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
17208 export function ChannelConfig_clone(orig: bigint): bigint {
17209 if(!isWasmInitialized) {
17210 throw new Error("initializeWasm() must be awaited first!");
17212 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
17213 return nativeResponseValue;
17215 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
17217 export function ChannelConfig_default(): bigint {
17218 if(!isWasmInitialized) {
17219 throw new Error("initializeWasm() must be awaited first!");
17221 const nativeResponseValue = wasm.TS_ChannelConfig_default();
17222 return nativeResponseValue;
17224 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
17226 export function ChannelConfig_write(obj: bigint): number {
17227 if(!isWasmInitialized) {
17228 throw new Error("initializeWasm() must be awaited first!");
17230 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
17231 return nativeResponseValue;
17233 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
17235 export function ChannelConfig_read(ser: number): bigint {
17236 if(!isWasmInitialized) {
17237 throw new Error("initializeWasm() must be awaited first!");
17239 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
17240 return nativeResponseValue;
17242 // void UserConfig_free(struct LDKUserConfig this_obj);
17244 export function UserConfig_free(this_obj: bigint): void {
17245 if(!isWasmInitialized) {
17246 throw new Error("initializeWasm() must be awaited first!");
17248 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
17249 // debug statements here
17251 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17253 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
17254 if(!isWasmInitialized) {
17255 throw new Error("initializeWasm() must be awaited first!");
17257 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
17258 return nativeResponseValue;
17260 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
17262 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
17263 if(!isWasmInitialized) {
17264 throw new Error("initializeWasm() must be awaited first!");
17266 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
17267 // debug statements here
17269 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17271 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
17272 if(!isWasmInitialized) {
17273 throw new Error("initializeWasm() must be awaited first!");
17275 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
17276 return nativeResponseValue;
17278 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
17280 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
17281 if(!isWasmInitialized) {
17282 throw new Error("initializeWasm() must be awaited first!");
17284 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
17285 // debug statements here
17287 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17289 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
17290 if(!isWasmInitialized) {
17291 throw new Error("initializeWasm() must be awaited first!");
17293 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
17294 return nativeResponseValue;
17296 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
17298 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
17299 if(!isWasmInitialized) {
17300 throw new Error("initializeWasm() must be awaited first!");
17302 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
17303 // debug statements here
17305 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17307 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
17308 if(!isWasmInitialized) {
17309 throw new Error("initializeWasm() must be awaited first!");
17311 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
17312 return nativeResponseValue;
17314 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17316 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
17317 if(!isWasmInitialized) {
17318 throw new Error("initializeWasm() must be awaited first!");
17320 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
17321 // debug statements here
17323 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17325 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
17326 if(!isWasmInitialized) {
17327 throw new Error("initializeWasm() must be awaited first!");
17329 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
17330 return nativeResponseValue;
17332 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17334 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
17335 if(!isWasmInitialized) {
17336 throw new Error("initializeWasm() must be awaited first!");
17338 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
17339 // debug statements here
17341 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17343 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
17344 if(!isWasmInitialized) {
17345 throw new Error("initializeWasm() must be awaited first!");
17347 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
17348 return nativeResponseValue;
17350 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17352 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
17353 if(!isWasmInitialized) {
17354 throw new Error("initializeWasm() must be awaited first!");
17356 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
17357 // debug statements here
17359 // 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);
17361 export function UserConfig_new(channel_handshake_config_arg: bigint, channel_handshake_limits_arg: bigint, channel_config_arg: bigint, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean, manually_accept_inbound_channels_arg: boolean): bigint {
17362 if(!isWasmInitialized) {
17363 throw new Error("initializeWasm() must be awaited first!");
17365 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);
17366 return nativeResponseValue;
17368 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
17370 export function UserConfig_clone_ptr(arg: bigint): bigint {
17371 if(!isWasmInitialized) {
17372 throw new Error("initializeWasm() must be awaited first!");
17374 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
17375 return nativeResponseValue;
17377 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
17379 export function UserConfig_clone(orig: bigint): bigint {
17380 if(!isWasmInitialized) {
17381 throw new Error("initializeWasm() must be awaited first!");
17383 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
17384 return nativeResponseValue;
17386 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
17388 export function UserConfig_default(): bigint {
17389 if(!isWasmInitialized) {
17390 throw new Error("initializeWasm() must be awaited first!");
17392 const nativeResponseValue = wasm.TS_UserConfig_default();
17393 return nativeResponseValue;
17395 // void BestBlock_free(struct LDKBestBlock this_obj);
17397 export function BestBlock_free(this_obj: bigint): void {
17398 if(!isWasmInitialized) {
17399 throw new Error("initializeWasm() must be awaited first!");
17401 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
17402 // debug statements here
17404 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
17406 export function BestBlock_clone_ptr(arg: bigint): bigint {
17407 if(!isWasmInitialized) {
17408 throw new Error("initializeWasm() must be awaited first!");
17410 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
17411 return nativeResponseValue;
17413 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
17415 export function BestBlock_clone(orig: bigint): bigint {
17416 if(!isWasmInitialized) {
17417 throw new Error("initializeWasm() must be awaited first!");
17419 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
17420 return nativeResponseValue;
17422 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
17424 export function BestBlock_from_genesis(network: Network): bigint {
17425 if(!isWasmInitialized) {
17426 throw new Error("initializeWasm() must be awaited first!");
17428 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
17429 return nativeResponseValue;
17431 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
17433 export function BestBlock_new(block_hash: number, height: number): bigint {
17434 if(!isWasmInitialized) {
17435 throw new Error("initializeWasm() must be awaited first!");
17437 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
17438 return nativeResponseValue;
17440 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
17442 export function BestBlock_block_hash(this_arg: bigint): number {
17443 if(!isWasmInitialized) {
17444 throw new Error("initializeWasm() must be awaited first!");
17446 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
17447 return nativeResponseValue;
17449 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
17451 export function BestBlock_height(this_arg: bigint): number {
17452 if(!isWasmInitialized) {
17453 throw new Error("initializeWasm() must be awaited first!");
17455 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
17456 return nativeResponseValue;
17458 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
17460 export function AccessError_clone(orig: bigint): AccessError {
17461 if(!isWasmInitialized) {
17462 throw new Error("initializeWasm() must be awaited first!");
17464 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
17465 return nativeResponseValue;
17467 // enum LDKAccessError AccessError_unknown_chain(void);
17469 export function AccessError_unknown_chain(): AccessError {
17470 if(!isWasmInitialized) {
17471 throw new Error("initializeWasm() must be awaited first!");
17473 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
17474 return nativeResponseValue;
17476 // enum LDKAccessError AccessError_unknown_tx(void);
17478 export function AccessError_unknown_tx(): AccessError {
17479 if(!isWasmInitialized) {
17480 throw new Error("initializeWasm() must be awaited first!");
17482 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
17483 return nativeResponseValue;
17485 // void Access_free(struct LDKAccess this_ptr);
17487 export function Access_free(this_ptr: bigint): void {
17488 if(!isWasmInitialized) {
17489 throw new Error("initializeWasm() must be awaited first!");
17491 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
17492 // debug statements here
17494 // void Listen_free(struct LDKListen this_ptr);
17496 export function Listen_free(this_ptr: bigint): void {
17497 if(!isWasmInitialized) {
17498 throw new Error("initializeWasm() must be awaited first!");
17500 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
17501 // debug statements here
17503 // void Confirm_free(struct LDKConfirm this_ptr);
17505 export function Confirm_free(this_ptr: bigint): void {
17506 if(!isWasmInitialized) {
17507 throw new Error("initializeWasm() must be awaited first!");
17509 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
17510 // debug statements here
17512 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
17514 export function ChannelMonitorUpdateErr_clone(orig: bigint): ChannelMonitorUpdateErr {
17515 if(!isWasmInitialized) {
17516 throw new Error("initializeWasm() must be awaited first!");
17518 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
17519 return nativeResponseValue;
17521 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
17523 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
17524 if(!isWasmInitialized) {
17525 throw new Error("initializeWasm() must be awaited first!");
17527 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
17528 return nativeResponseValue;
17530 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
17532 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
17533 if(!isWasmInitialized) {
17534 throw new Error("initializeWasm() must be awaited first!");
17536 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
17537 return nativeResponseValue;
17539 // void Watch_free(struct LDKWatch this_ptr);
17541 export function Watch_free(this_ptr: bigint): void {
17542 if(!isWasmInitialized) {
17543 throw new Error("initializeWasm() must be awaited first!");
17545 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
17546 // debug statements here
17548 // void Filter_free(struct LDKFilter this_ptr);
17550 export function Filter_free(this_ptr: bigint): void {
17551 if(!isWasmInitialized) {
17552 throw new Error("initializeWasm() must be awaited first!");
17554 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
17555 // debug statements here
17557 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
17559 export function WatchedOutput_free(this_obj: bigint): void {
17560 if(!isWasmInitialized) {
17561 throw new Error("initializeWasm() must be awaited first!");
17563 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
17564 // debug statements here
17566 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17568 export function WatchedOutput_get_block_hash(this_ptr: bigint): number {
17569 if(!isWasmInitialized) {
17570 throw new Error("initializeWasm() must be awaited first!");
17572 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
17573 return nativeResponseValue;
17575 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17577 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: number): void {
17578 if(!isWasmInitialized) {
17579 throw new Error("initializeWasm() must be awaited first!");
17581 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
17582 // debug statements here
17584 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17586 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
17587 if(!isWasmInitialized) {
17588 throw new Error("initializeWasm() must be awaited first!");
17590 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
17591 return nativeResponseValue;
17593 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17595 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
17596 if(!isWasmInitialized) {
17597 throw new Error("initializeWasm() must be awaited first!");
17599 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
17600 // debug statements here
17602 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17604 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
17605 if(!isWasmInitialized) {
17606 throw new Error("initializeWasm() must be awaited first!");
17608 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
17609 return nativeResponseValue;
17611 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17613 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
17614 if(!isWasmInitialized) {
17615 throw new Error("initializeWasm() must be awaited first!");
17617 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
17618 // debug statements here
17620 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
17622 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
17623 if(!isWasmInitialized) {
17624 throw new Error("initializeWasm() must be awaited first!");
17626 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
17627 return nativeResponseValue;
17629 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
17631 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
17632 if(!isWasmInitialized) {
17633 throw new Error("initializeWasm() must be awaited first!");
17635 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
17636 return nativeResponseValue;
17638 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
17640 export function WatchedOutput_clone(orig: bigint): bigint {
17641 if(!isWasmInitialized) {
17642 throw new Error("initializeWasm() must be awaited first!");
17644 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
17645 return nativeResponseValue;
17647 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
17649 export function WatchedOutput_hash(o: bigint): bigint {
17650 if(!isWasmInitialized) {
17651 throw new Error("initializeWasm() must be awaited first!");
17653 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
17654 return nativeResponseValue;
17656 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
17658 export function BroadcasterInterface_free(this_ptr: bigint): void {
17659 if(!isWasmInitialized) {
17660 throw new Error("initializeWasm() must be awaited first!");
17662 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
17663 // debug statements here
17665 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
17667 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
17668 if(!isWasmInitialized) {
17669 throw new Error("initializeWasm() must be awaited first!");
17671 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
17672 return nativeResponseValue;
17674 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
17676 export function ConfirmationTarget_background(): ConfirmationTarget {
17677 if(!isWasmInitialized) {
17678 throw new Error("initializeWasm() must be awaited first!");
17680 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
17681 return nativeResponseValue;
17683 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
17685 export function ConfirmationTarget_normal(): ConfirmationTarget {
17686 if(!isWasmInitialized) {
17687 throw new Error("initializeWasm() must be awaited first!");
17689 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
17690 return nativeResponseValue;
17692 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
17694 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
17695 if(!isWasmInitialized) {
17696 throw new Error("initializeWasm() must be awaited first!");
17698 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
17699 return nativeResponseValue;
17701 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
17703 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
17704 if(!isWasmInitialized) {
17705 throw new Error("initializeWasm() must be awaited first!");
17707 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
17708 return nativeResponseValue;
17710 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17712 export function FeeEstimator_free(this_ptr: bigint): void {
17713 if(!isWasmInitialized) {
17714 throw new Error("initializeWasm() must be awaited first!");
17716 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17717 // debug statements here
17719 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17721 export function MonitorUpdateId_free(this_obj: bigint): void {
17722 if(!isWasmInitialized) {
17723 throw new Error("initializeWasm() must be awaited first!");
17725 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17726 // debug statements here
17728 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17730 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
17731 if(!isWasmInitialized) {
17732 throw new Error("initializeWasm() must be awaited first!");
17734 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17735 return nativeResponseValue;
17737 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17739 export function MonitorUpdateId_clone(orig: bigint): bigint {
17740 if(!isWasmInitialized) {
17741 throw new Error("initializeWasm() must be awaited first!");
17743 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17744 return nativeResponseValue;
17746 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17748 export function MonitorUpdateId_hash(o: bigint): bigint {
17749 if(!isWasmInitialized) {
17750 throw new Error("initializeWasm() must be awaited first!");
17752 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17753 return nativeResponseValue;
17755 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17757 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
17758 if(!isWasmInitialized) {
17759 throw new Error("initializeWasm() must be awaited first!");
17761 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17762 return nativeResponseValue;
17764 // void Persist_free(struct LDKPersist this_ptr);
17766 export function Persist_free(this_ptr: bigint): void {
17767 if(!isWasmInitialized) {
17768 throw new Error("initializeWasm() must be awaited first!");
17770 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17771 // debug statements here
17773 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17775 export function LockedChannelMonitor_free(this_obj: bigint): void {
17776 if(!isWasmInitialized) {
17777 throw new Error("initializeWasm() must be awaited first!");
17779 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17780 // debug statements here
17782 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17784 export function ChainMonitor_free(this_obj: bigint): void {
17785 if(!isWasmInitialized) {
17786 throw new Error("initializeWasm() must be awaited first!");
17788 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17789 // debug statements here
17791 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17793 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
17794 if(!isWasmInitialized) {
17795 throw new Error("initializeWasm() must be awaited first!");
17797 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17798 return nativeResponseValue;
17800 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17802 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
17803 if(!isWasmInitialized) {
17804 throw new Error("initializeWasm() must be awaited first!");
17806 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17807 return nativeResponseValue;
17809 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17811 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
17812 if(!isWasmInitialized) {
17813 throw new Error("initializeWasm() must be awaited first!");
17815 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17816 return nativeResponseValue;
17818 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17820 export function ChainMonitor_list_monitors(this_arg: bigint): number {
17821 if(!isWasmInitialized) {
17822 throw new Error("initializeWasm() must be awaited first!");
17824 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17825 return nativeResponseValue;
17827 // 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);
17829 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
17830 if(!isWasmInitialized) {
17831 throw new Error("initializeWasm() must be awaited first!");
17833 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17834 return nativeResponseValue;
17836 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17838 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
17839 if(!isWasmInitialized) {
17840 throw new Error("initializeWasm() must be awaited first!");
17842 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17843 return nativeResponseValue;
17845 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17847 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
17848 if(!isWasmInitialized) {
17849 throw new Error("initializeWasm() must be awaited first!");
17851 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17852 return nativeResponseValue;
17854 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17856 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
17857 if(!isWasmInitialized) {
17858 throw new Error("initializeWasm() must be awaited first!");
17860 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17861 return nativeResponseValue;
17863 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17865 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
17866 if(!isWasmInitialized) {
17867 throw new Error("initializeWasm() must be awaited first!");
17869 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17870 return nativeResponseValue;
17872 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17874 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
17875 if(!isWasmInitialized) {
17876 throw new Error("initializeWasm() must be awaited first!");
17878 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17879 // debug statements here
17881 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17883 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
17884 if(!isWasmInitialized) {
17885 throw new Error("initializeWasm() must be awaited first!");
17887 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17888 return nativeResponseValue;
17890 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17892 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
17893 if(!isWasmInitialized) {
17894 throw new Error("initializeWasm() must be awaited first!");
17896 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17897 // debug statements here
17899 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17901 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
17902 if(!isWasmInitialized) {
17903 throw new Error("initializeWasm() must be awaited first!");
17905 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17906 return nativeResponseValue;
17908 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17910 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
17911 if(!isWasmInitialized) {
17912 throw new Error("initializeWasm() must be awaited first!");
17914 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17915 return nativeResponseValue;
17917 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17919 export function ChannelMonitorUpdate_write(obj: bigint): number {
17920 if(!isWasmInitialized) {
17921 throw new Error("initializeWasm() must be awaited first!");
17923 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17924 return nativeResponseValue;
17926 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17928 export function ChannelMonitorUpdate_read(ser: number): bigint {
17929 if(!isWasmInitialized) {
17930 throw new Error("initializeWasm() must be awaited first!");
17932 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17933 return nativeResponseValue;
17935 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17937 export function MonitorEvent_free(this_ptr: bigint): void {
17938 if(!isWasmInitialized) {
17939 throw new Error("initializeWasm() must be awaited first!");
17941 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17942 // debug statements here
17944 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17946 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
17947 if(!isWasmInitialized) {
17948 throw new Error("initializeWasm() must be awaited first!");
17950 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17951 return nativeResponseValue;
17953 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17955 export function MonitorEvent_clone(orig: bigint): bigint {
17956 if(!isWasmInitialized) {
17957 throw new Error("initializeWasm() must be awaited first!");
17959 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17960 return nativeResponseValue;
17962 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17964 export function MonitorEvent_htlcevent(a: bigint): bigint {
17965 if(!isWasmInitialized) {
17966 throw new Error("initializeWasm() must be awaited first!");
17968 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17969 return nativeResponseValue;
17971 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17973 export function MonitorEvent_commitment_tx_confirmed(a: bigint): bigint {
17974 if(!isWasmInitialized) {
17975 throw new Error("initializeWasm() must be awaited first!");
17977 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17978 return nativeResponseValue;
17980 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17982 export function MonitorEvent_update_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
17983 if(!isWasmInitialized) {
17984 throw new Error("initializeWasm() must be awaited first!");
17986 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17987 return nativeResponseValue;
17989 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17991 export function MonitorEvent_update_failed(a: bigint): bigint {
17992 if(!isWasmInitialized) {
17993 throw new Error("initializeWasm() must be awaited first!");
17995 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17996 return nativeResponseValue;
17998 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
18000 export function MonitorEvent_write(obj: bigint): number {
18001 if(!isWasmInitialized) {
18002 throw new Error("initializeWasm() must be awaited first!");
18004 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
18005 return nativeResponseValue;
18007 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
18009 export function MonitorEvent_read(ser: number): bigint {
18010 if(!isWasmInitialized) {
18011 throw new Error("initializeWasm() must be awaited first!");
18013 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
18014 return nativeResponseValue;
18016 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
18018 export function HTLCUpdate_free(this_obj: bigint): void {
18019 if(!isWasmInitialized) {
18020 throw new Error("initializeWasm() must be awaited first!");
18022 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
18023 // debug statements here
18025 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
18027 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
18028 if(!isWasmInitialized) {
18029 throw new Error("initializeWasm() must be awaited first!");
18031 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
18032 return nativeResponseValue;
18034 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
18036 export function HTLCUpdate_clone(orig: bigint): bigint {
18037 if(!isWasmInitialized) {
18038 throw new Error("initializeWasm() must be awaited first!");
18040 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
18041 return nativeResponseValue;
18043 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
18045 export function HTLCUpdate_write(obj: bigint): number {
18046 if(!isWasmInitialized) {
18047 throw new Error("initializeWasm() must be awaited first!");
18049 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
18050 return nativeResponseValue;
18052 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
18054 export function HTLCUpdate_read(ser: number): bigint {
18055 if(!isWasmInitialized) {
18056 throw new Error("initializeWasm() must be awaited first!");
18058 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
18059 return nativeResponseValue;
18061 // void Balance_free(struct LDKBalance this_ptr);
18063 export function Balance_free(this_ptr: bigint): void {
18064 if(!isWasmInitialized) {
18065 throw new Error("initializeWasm() must be awaited first!");
18067 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
18068 // debug statements here
18070 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
18072 export function Balance_clone_ptr(arg: bigint): bigint {
18073 if(!isWasmInitialized) {
18074 throw new Error("initializeWasm() must be awaited first!");
18076 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
18077 return nativeResponseValue;
18079 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
18081 export function Balance_clone(orig: bigint): bigint {
18082 if(!isWasmInitialized) {
18083 throw new Error("initializeWasm() must be awaited first!");
18085 const nativeResponseValue = wasm.TS_Balance_clone(orig);
18086 return nativeResponseValue;
18088 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
18090 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): bigint {
18091 if(!isWasmInitialized) {
18092 throw new Error("initializeWasm() must be awaited first!");
18094 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
18095 return nativeResponseValue;
18097 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
18099 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): bigint {
18100 if(!isWasmInitialized) {
18101 throw new Error("initializeWasm() must be awaited first!");
18103 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
18104 return nativeResponseValue;
18106 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
18108 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): bigint {
18109 if(!isWasmInitialized) {
18110 throw new Error("initializeWasm() must be awaited first!");
18112 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
18113 return nativeResponseValue;
18115 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
18117 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): bigint {
18118 if(!isWasmInitialized) {
18119 throw new Error("initializeWasm() must be awaited first!");
18121 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
18122 return nativeResponseValue;
18124 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
18126 export function Balance_eq(a: bigint, b: bigint): boolean {
18127 if(!isWasmInitialized) {
18128 throw new Error("initializeWasm() must be awaited first!");
18130 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
18131 return nativeResponseValue;
18133 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
18135 export function ChannelMonitor_free(this_obj: bigint): void {
18136 if(!isWasmInitialized) {
18137 throw new Error("initializeWasm() must be awaited first!");
18139 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
18140 // debug statements here
18142 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
18144 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
18145 if(!isWasmInitialized) {
18146 throw new Error("initializeWasm() must be awaited first!");
18148 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
18149 return nativeResponseValue;
18151 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
18153 export function ChannelMonitor_clone(orig: bigint): bigint {
18154 if(!isWasmInitialized) {
18155 throw new Error("initializeWasm() must be awaited first!");
18157 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
18158 return nativeResponseValue;
18160 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
18162 export function ChannelMonitor_write(obj: bigint): number {
18163 if(!isWasmInitialized) {
18164 throw new Error("initializeWasm() must be awaited first!");
18166 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
18167 return nativeResponseValue;
18169 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
18171 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
18172 if(!isWasmInitialized) {
18173 throw new Error("initializeWasm() must be awaited first!");
18175 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
18176 return nativeResponseValue;
18178 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18180 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
18181 if(!isWasmInitialized) {
18182 throw new Error("initializeWasm() must be awaited first!");
18184 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
18185 return nativeResponseValue;
18187 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18189 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
18190 if(!isWasmInitialized) {
18191 throw new Error("initializeWasm() must be awaited first!");
18193 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
18194 return nativeResponseValue;
18196 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18198 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
18199 if(!isWasmInitialized) {
18200 throw new Error("initializeWasm() must be awaited first!");
18202 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
18203 return nativeResponseValue;
18205 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
18207 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
18208 if(!isWasmInitialized) {
18209 throw new Error("initializeWasm() must be awaited first!");
18211 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
18212 // debug statements here
18214 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18216 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
18217 if(!isWasmInitialized) {
18218 throw new Error("initializeWasm() must be awaited first!");
18220 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
18221 return nativeResponseValue;
18223 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18225 export function ChannelMonitor_get_and_clear_pending_events(this_arg: bigint): number {
18226 if(!isWasmInitialized) {
18227 throw new Error("initializeWasm() must be awaited first!");
18229 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
18230 return nativeResponseValue;
18232 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18234 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
18235 if(!isWasmInitialized) {
18236 throw new Error("initializeWasm() must be awaited first!");
18238 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
18239 return nativeResponseValue;
18241 // 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);
18243 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
18244 if(!isWasmInitialized) {
18245 throw new Error("initializeWasm() must be awaited first!");
18247 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
18248 return nativeResponseValue;
18250 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
18252 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
18253 if(!isWasmInitialized) {
18254 throw new Error("initializeWasm() must be awaited first!");
18256 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
18257 return nativeResponseValue;
18259 // 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);
18261 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
18262 if(!isWasmInitialized) {
18263 throw new Error("initializeWasm() must be awaited first!");
18265 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
18266 // debug statements here
18268 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_transactions_confirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
18270 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
18271 if(!isWasmInitialized) {
18272 throw new Error("initializeWasm() must be awaited first!");
18274 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
18275 return nativeResponseValue;
18277 // 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);
18279 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
18280 if(!isWasmInitialized) {
18281 throw new Error("initializeWasm() must be awaited first!");
18283 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
18284 // debug statements here
18286 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_best_block_updated(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
18288 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
18289 if(!isWasmInitialized) {
18290 throw new Error("initializeWasm() must be awaited first!");
18292 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
18293 return nativeResponseValue;
18295 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18297 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
18298 if(!isWasmInitialized) {
18299 throw new Error("initializeWasm() must be awaited first!");
18301 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
18302 return nativeResponseValue;
18304 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18306 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
18307 if(!isWasmInitialized) {
18308 throw new Error("initializeWasm() must be awaited first!");
18310 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
18311 return nativeResponseValue;
18313 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18315 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
18316 if(!isWasmInitialized) {
18317 throw new Error("initializeWasm() must be awaited first!");
18319 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
18320 return nativeResponseValue;
18322 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
18324 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: bigint): bigint {
18325 if(!isWasmInitialized) {
18326 throw new Error("initializeWasm() must be awaited first!");
18328 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
18329 return nativeResponseValue;
18331 // void OutPoint_free(struct LDKOutPoint this_obj);
18333 export function OutPoint_free(this_obj: bigint): void {
18334 if(!isWasmInitialized) {
18335 throw new Error("initializeWasm() must be awaited first!");
18337 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
18338 // debug statements here
18340 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
18342 export function OutPoint_get_txid(this_ptr: bigint): number {
18343 if(!isWasmInitialized) {
18344 throw new Error("initializeWasm() must be awaited first!");
18346 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
18347 return nativeResponseValue;
18349 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18351 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
18352 if(!isWasmInitialized) {
18353 throw new Error("initializeWasm() must be awaited first!");
18355 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
18356 // debug statements here
18358 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
18360 export function OutPoint_get_index(this_ptr: bigint): number {
18361 if(!isWasmInitialized) {
18362 throw new Error("initializeWasm() must be awaited first!");
18364 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
18365 return nativeResponseValue;
18367 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
18369 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
18370 if(!isWasmInitialized) {
18371 throw new Error("initializeWasm() must be awaited first!");
18373 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
18374 // debug statements here
18376 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
18378 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
18379 if(!isWasmInitialized) {
18380 throw new Error("initializeWasm() must be awaited first!");
18382 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
18383 return nativeResponseValue;
18385 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
18387 export function OutPoint_clone_ptr(arg: bigint): bigint {
18388 if(!isWasmInitialized) {
18389 throw new Error("initializeWasm() must be awaited first!");
18391 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
18392 return nativeResponseValue;
18394 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
18396 export function OutPoint_clone(orig: bigint): bigint {
18397 if(!isWasmInitialized) {
18398 throw new Error("initializeWasm() must be awaited first!");
18400 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
18401 return nativeResponseValue;
18403 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
18405 export function OutPoint_eq(a: bigint, b: bigint): boolean {
18406 if(!isWasmInitialized) {
18407 throw new Error("initializeWasm() must be awaited first!");
18409 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
18410 return nativeResponseValue;
18412 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
18414 export function OutPoint_hash(o: bigint): bigint {
18415 if(!isWasmInitialized) {
18416 throw new Error("initializeWasm() must be awaited first!");
18418 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
18419 return nativeResponseValue;
18421 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
18423 export function OutPoint_to_channel_id(this_arg: bigint): number {
18424 if(!isWasmInitialized) {
18425 throw new Error("initializeWasm() must be awaited first!");
18427 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
18428 return nativeResponseValue;
18430 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
18432 export function OutPoint_write(obj: bigint): number {
18433 if(!isWasmInitialized) {
18434 throw new Error("initializeWasm() must be awaited first!");
18436 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
18437 return nativeResponseValue;
18439 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
18441 export function OutPoint_read(ser: number): bigint {
18442 if(!isWasmInitialized) {
18443 throw new Error("initializeWasm() must be awaited first!");
18445 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
18446 return nativeResponseValue;
18448 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
18450 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
18451 if(!isWasmInitialized) {
18452 throw new Error("initializeWasm() must be awaited first!");
18454 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
18455 // debug statements here
18457 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18459 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
18460 if(!isWasmInitialized) {
18461 throw new Error("initializeWasm() must be awaited first!");
18463 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
18464 return nativeResponseValue;
18466 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18468 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
18469 if(!isWasmInitialized) {
18470 throw new Error("initializeWasm() must be awaited first!");
18472 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18473 // debug statements here
18475 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18477 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
18478 if(!isWasmInitialized) {
18479 throw new Error("initializeWasm() must be awaited first!");
18481 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
18482 return nativeResponseValue;
18484 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18486 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
18487 if(!isWasmInitialized) {
18488 throw new Error("initializeWasm() must be awaited first!");
18490 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
18491 // debug statements here
18493 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18495 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
18496 if(!isWasmInitialized) {
18497 throw new Error("initializeWasm() must be awaited first!");
18499 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
18500 return nativeResponseValue;
18502 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
18504 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
18505 if(!isWasmInitialized) {
18506 throw new Error("initializeWasm() must be awaited first!");
18508 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
18509 // debug statements here
18511 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18513 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
18514 if(!isWasmInitialized) {
18515 throw new Error("initializeWasm() must be awaited first!");
18517 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
18518 return nativeResponseValue;
18520 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18522 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
18523 if(!isWasmInitialized) {
18524 throw new Error("initializeWasm() must be awaited first!");
18526 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
18527 // debug statements here
18529 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18531 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
18532 if(!isWasmInitialized) {
18533 throw new Error("initializeWasm() must be awaited first!");
18535 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
18536 return nativeResponseValue;
18538 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18540 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
18541 if(!isWasmInitialized) {
18542 throw new Error("initializeWasm() must be awaited first!");
18544 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
18545 // debug statements here
18547 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18549 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
18550 if(!isWasmInitialized) {
18551 throw new Error("initializeWasm() must be awaited first!");
18553 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18554 return nativeResponseValue;
18556 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18558 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
18559 if(!isWasmInitialized) {
18560 throw new Error("initializeWasm() must be awaited first!");
18562 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18563 // debug statements here
18565 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18567 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
18568 if(!isWasmInitialized) {
18569 throw new Error("initializeWasm() must be awaited first!");
18571 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18572 return nativeResponseValue;
18574 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18576 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
18577 if(!isWasmInitialized) {
18578 throw new Error("initializeWasm() must be awaited first!");
18580 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18581 // debug statements here
18583 // 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);
18585 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 {
18586 if(!isWasmInitialized) {
18587 throw new Error("initializeWasm() must be awaited first!");
18589 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);
18590 return nativeResponseValue;
18592 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
18594 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
18595 if(!isWasmInitialized) {
18596 throw new Error("initializeWasm() must be awaited first!");
18598 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
18599 return nativeResponseValue;
18601 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
18603 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
18604 if(!isWasmInitialized) {
18605 throw new Error("initializeWasm() must be awaited first!");
18607 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
18608 return nativeResponseValue;
18610 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
18612 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
18613 if(!isWasmInitialized) {
18614 throw new Error("initializeWasm() must be awaited first!");
18616 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
18617 return nativeResponseValue;
18619 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
18621 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
18622 if(!isWasmInitialized) {
18623 throw new Error("initializeWasm() must be awaited first!");
18625 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
18626 return nativeResponseValue;
18628 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
18630 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
18631 if(!isWasmInitialized) {
18632 throw new Error("initializeWasm() must be awaited first!");
18634 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
18635 // debug statements here
18637 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18639 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
18640 if(!isWasmInitialized) {
18641 throw new Error("initializeWasm() must be awaited first!");
18643 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
18644 return nativeResponseValue;
18646 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18648 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
18649 if(!isWasmInitialized) {
18650 throw new Error("initializeWasm() must be awaited first!");
18652 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18653 // debug statements here
18655 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18657 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
18658 if(!isWasmInitialized) {
18659 throw new Error("initializeWasm() must be awaited first!");
18661 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
18662 return nativeResponseValue;
18664 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18666 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
18667 if(!isWasmInitialized) {
18668 throw new Error("initializeWasm() must be awaited first!");
18670 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
18671 // debug statements here
18673 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18675 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
18676 if(!isWasmInitialized) {
18677 throw new Error("initializeWasm() must be awaited first!");
18679 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18680 return nativeResponseValue;
18682 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18684 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
18685 if(!isWasmInitialized) {
18686 throw new Error("initializeWasm() must be awaited first!");
18688 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18689 // debug statements here
18691 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18693 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
18694 if(!isWasmInitialized) {
18695 throw new Error("initializeWasm() must be awaited first!");
18697 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18698 return nativeResponseValue;
18700 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18702 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
18703 if(!isWasmInitialized) {
18704 throw new Error("initializeWasm() must be awaited first!");
18706 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18707 // debug statements here
18709 // 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);
18711 export function StaticPaymentOutputDescriptor_new(outpoint_arg: bigint, output_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
18712 if(!isWasmInitialized) {
18713 throw new Error("initializeWasm() must be awaited first!");
18715 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
18716 return nativeResponseValue;
18718 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
18720 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
18721 if(!isWasmInitialized) {
18722 throw new Error("initializeWasm() must be awaited first!");
18724 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
18725 return nativeResponseValue;
18727 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
18729 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
18730 if(!isWasmInitialized) {
18731 throw new Error("initializeWasm() must be awaited first!");
18733 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
18734 return nativeResponseValue;
18736 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18738 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
18739 if(!isWasmInitialized) {
18740 throw new Error("initializeWasm() must be awaited first!");
18742 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18743 return nativeResponseValue;
18745 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18747 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
18748 if(!isWasmInitialized) {
18749 throw new Error("initializeWasm() must be awaited first!");
18751 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18752 return nativeResponseValue;
18754 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18756 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
18757 if(!isWasmInitialized) {
18758 throw new Error("initializeWasm() must be awaited first!");
18760 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18761 // debug statements here
18763 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18765 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
18766 if(!isWasmInitialized) {
18767 throw new Error("initializeWasm() must be awaited first!");
18769 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18770 return nativeResponseValue;
18772 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18774 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
18775 if(!isWasmInitialized) {
18776 throw new Error("initializeWasm() must be awaited first!");
18778 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18779 return nativeResponseValue;
18781 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18783 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
18784 if(!isWasmInitialized) {
18785 throw new Error("initializeWasm() must be awaited first!");
18787 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18788 return nativeResponseValue;
18790 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18792 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
18793 if(!isWasmInitialized) {
18794 throw new Error("initializeWasm() must be awaited first!");
18796 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18797 return nativeResponseValue;
18799 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18801 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
18802 if(!isWasmInitialized) {
18803 throw new Error("initializeWasm() must be awaited first!");
18805 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18806 return nativeResponseValue;
18808 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18810 export function SpendableOutputDescriptor_write(obj: bigint): number {
18811 if(!isWasmInitialized) {
18812 throw new Error("initializeWasm() must be awaited first!");
18814 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18815 return nativeResponseValue;
18817 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18819 export function SpendableOutputDescriptor_read(ser: number): bigint {
18820 if(!isWasmInitialized) {
18821 throw new Error("initializeWasm() must be awaited first!");
18823 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18824 return nativeResponseValue;
18826 // void BaseSign_free(struct LDKBaseSign this_ptr);
18828 export function BaseSign_free(this_ptr: bigint): void {
18829 if(!isWasmInitialized) {
18830 throw new Error("initializeWasm() must be awaited first!");
18832 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18833 // debug statements here
18835 // uint64_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18837 export function Sign_clone_ptr(arg: bigint): bigint {
18838 if(!isWasmInitialized) {
18839 throw new Error("initializeWasm() must be awaited first!");
18841 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18842 return nativeResponseValue;
18844 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18846 export function Sign_clone(orig: bigint): bigint {
18847 if(!isWasmInitialized) {
18848 throw new Error("initializeWasm() must be awaited first!");
18850 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18851 return nativeResponseValue;
18853 // void Sign_free(struct LDKSign this_ptr);
18855 export function Sign_free(this_ptr: bigint): void {
18856 if(!isWasmInitialized) {
18857 throw new Error("initializeWasm() must be awaited first!");
18859 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18860 // debug statements here
18862 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18864 export function Recipient_clone(orig: bigint): Recipient {
18865 if(!isWasmInitialized) {
18866 throw new Error("initializeWasm() must be awaited first!");
18868 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18869 return nativeResponseValue;
18871 // enum LDKRecipient Recipient_node(void);
18873 export function Recipient_node(): Recipient {
18874 if(!isWasmInitialized) {
18875 throw new Error("initializeWasm() must be awaited first!");
18877 const nativeResponseValue = wasm.TS_Recipient_node();
18878 return nativeResponseValue;
18880 // enum LDKRecipient Recipient_phantom_node(void);
18882 export function Recipient_phantom_node(): Recipient {
18883 if(!isWasmInitialized) {
18884 throw new Error("initializeWasm() must be awaited first!");
18886 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18887 return nativeResponseValue;
18889 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18891 export function KeysInterface_free(this_ptr: bigint): void {
18892 if(!isWasmInitialized) {
18893 throw new Error("initializeWasm() must be awaited first!");
18895 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18896 // debug statements here
18898 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18900 export function InMemorySigner_free(this_obj: bigint): void {
18901 if(!isWasmInitialized) {
18902 throw new Error("initializeWasm() must be awaited first!");
18904 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18905 // debug statements here
18907 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18909 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
18910 if(!isWasmInitialized) {
18911 throw new Error("initializeWasm() must be awaited first!");
18913 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18914 return nativeResponseValue;
18916 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18918 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
18919 if(!isWasmInitialized) {
18920 throw new Error("initializeWasm() must be awaited first!");
18922 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18923 // debug statements here
18925 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18927 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
18928 if(!isWasmInitialized) {
18929 throw new Error("initializeWasm() must be awaited first!");
18931 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18932 return nativeResponseValue;
18934 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18936 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
18937 if(!isWasmInitialized) {
18938 throw new Error("initializeWasm() must be awaited first!");
18940 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18941 // debug statements here
18943 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18945 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
18946 if(!isWasmInitialized) {
18947 throw new Error("initializeWasm() must be awaited first!");
18949 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18950 return nativeResponseValue;
18952 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18954 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
18955 if(!isWasmInitialized) {
18956 throw new Error("initializeWasm() must be awaited first!");
18958 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18959 // debug statements here
18961 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18963 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
18964 if(!isWasmInitialized) {
18965 throw new Error("initializeWasm() must be awaited first!");
18967 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18968 return nativeResponseValue;
18970 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18972 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
18973 if(!isWasmInitialized) {
18974 throw new Error("initializeWasm() must be awaited first!");
18976 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18977 // debug statements here
18979 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18981 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
18982 if(!isWasmInitialized) {
18983 throw new Error("initializeWasm() must be awaited first!");
18985 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18986 return nativeResponseValue;
18988 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18990 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
18991 if(!isWasmInitialized) {
18992 throw new Error("initializeWasm() must be awaited first!");
18994 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18995 // debug statements here
18997 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18999 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
19000 if(!isWasmInitialized) {
19001 throw new Error("initializeWasm() must be awaited first!");
19003 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
19004 return nativeResponseValue;
19006 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19008 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
19009 if(!isWasmInitialized) {
19010 throw new Error("initializeWasm() must be awaited first!");
19012 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
19013 // debug statements here
19015 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
19017 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
19018 if(!isWasmInitialized) {
19019 throw new Error("initializeWasm() must be awaited first!");
19021 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
19022 return nativeResponseValue;
19024 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
19026 export function InMemorySigner_clone(orig: bigint): bigint {
19027 if(!isWasmInitialized) {
19028 throw new Error("initializeWasm() must be awaited first!");
19030 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
19031 return nativeResponseValue;
19033 // MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey node_secret, struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
19035 export function InMemorySigner_new(node_secret: number, funding_key: number, revocation_base_key: number, payment_key: number, delayed_payment_base_key: number, htlc_base_key: number, commitment_seed: number, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
19036 if(!isWasmInitialized) {
19037 throw new Error("initializeWasm() must be awaited first!");
19039 const nativeResponseValue = wasm.TS_InMemorySigner_new(node_secret, funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
19040 return nativeResponseValue;
19042 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19044 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
19045 if(!isWasmInitialized) {
19046 throw new Error("initializeWasm() must be awaited first!");
19048 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
19049 return nativeResponseValue;
19051 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19053 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): number {
19054 if(!isWasmInitialized) {
19055 throw new Error("initializeWasm() must be awaited first!");
19057 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
19058 return nativeResponseValue;
19060 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19062 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): number {
19063 if(!isWasmInitialized) {
19064 throw new Error("initializeWasm() must be awaited first!");
19066 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
19067 return nativeResponseValue;
19069 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19071 export function InMemorySigner_is_outbound(this_arg: bigint): boolean {
19072 if(!isWasmInitialized) {
19073 throw new Error("initializeWasm() must be awaited first!");
19075 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
19076 return nativeResponseValue;
19078 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19080 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
19081 if(!isWasmInitialized) {
19082 throw new Error("initializeWasm() must be awaited first!");
19084 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
19085 return nativeResponseValue;
19087 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19089 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
19090 if(!isWasmInitialized) {
19091 throw new Error("initializeWasm() must be awaited first!");
19093 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
19094 return nativeResponseValue;
19096 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19098 export function InMemorySigner_opt_anchors(this_arg: bigint): boolean {
19099 if(!isWasmInitialized) {
19100 throw new Error("initializeWasm() must be awaited first!");
19102 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
19103 return nativeResponseValue;
19105 // 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);
19107 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
19108 if(!isWasmInitialized) {
19109 throw new Error("initializeWasm() must be awaited first!");
19111 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
19112 return nativeResponseValue;
19114 // 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);
19116 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
19117 if(!isWasmInitialized) {
19118 throw new Error("initializeWasm() must be awaited first!");
19120 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
19121 return nativeResponseValue;
19123 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19125 export function InMemorySigner_as_BaseSign(this_arg: bigint): bigint {
19126 if(!isWasmInitialized) {
19127 throw new Error("initializeWasm() must be awaited first!");
19129 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
19130 return nativeResponseValue;
19132 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19134 export function InMemorySigner_as_Sign(this_arg: bigint): bigint {
19135 if(!isWasmInitialized) {
19136 throw new Error("initializeWasm() must be awaited first!");
19138 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
19139 return nativeResponseValue;
19141 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
19143 export function InMemorySigner_write(obj: bigint): number {
19144 if(!isWasmInitialized) {
19145 throw new Error("initializeWasm() must be awaited first!");
19147 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
19148 return nativeResponseValue;
19150 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
19152 export function InMemorySigner_read(ser: number, arg: number): bigint {
19153 if(!isWasmInitialized) {
19154 throw new Error("initializeWasm() must be awaited first!");
19156 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
19157 return nativeResponseValue;
19159 // void KeysManager_free(struct LDKKeysManager this_obj);
19161 export function KeysManager_free(this_obj: bigint): void {
19162 if(!isWasmInitialized) {
19163 throw new Error("initializeWasm() must be awaited first!");
19165 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
19166 // debug statements here
19168 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
19170 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
19171 if(!isWasmInitialized) {
19172 throw new Error("initializeWasm() must be awaited first!");
19174 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
19175 return nativeResponseValue;
19177 // 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]);
19179 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
19180 if(!isWasmInitialized) {
19181 throw new Error("initializeWasm() must be awaited first!");
19183 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
19184 return nativeResponseValue;
19186 // 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);
19188 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
19189 if(!isWasmInitialized) {
19190 throw new Error("initializeWasm() must be awaited first!");
19192 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
19193 return nativeResponseValue;
19195 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
19197 export function KeysManager_as_KeysInterface(this_arg: bigint): bigint {
19198 if(!isWasmInitialized) {
19199 throw new Error("initializeWasm() must be awaited first!");
19201 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
19202 return nativeResponseValue;
19204 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
19206 export function PhantomKeysManager_free(this_obj: bigint): void {
19207 if(!isWasmInitialized) {
19208 throw new Error("initializeWasm() must be awaited first!");
19210 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
19211 // debug statements here
19213 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
19215 export function PhantomKeysManager_as_KeysInterface(this_arg: bigint): bigint {
19216 if(!isWasmInitialized) {
19217 throw new Error("initializeWasm() must be awaited first!");
19219 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
19220 return nativeResponseValue;
19222 // 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]);
19224 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
19225 if(!isWasmInitialized) {
19226 throw new Error("initializeWasm() must be awaited first!");
19228 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
19229 return nativeResponseValue;
19231 // 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);
19233 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): bigint {
19234 if(!isWasmInitialized) {
19235 throw new Error("initializeWasm() must be awaited first!");
19237 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
19238 return nativeResponseValue;
19240 // 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]);
19242 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
19243 if(!isWasmInitialized) {
19244 throw new Error("initializeWasm() must be awaited first!");
19246 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
19247 return nativeResponseValue;
19249 // void ChannelManager_free(struct LDKChannelManager this_obj);
19251 export function ChannelManager_free(this_obj: bigint): void {
19252 if(!isWasmInitialized) {
19253 throw new Error("initializeWasm() must be awaited first!");
19255 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
19256 // debug statements here
19258 // void ChainParameters_free(struct LDKChainParameters this_obj);
19260 export function ChainParameters_free(this_obj: bigint): void {
19261 if(!isWasmInitialized) {
19262 throw new Error("initializeWasm() must be awaited first!");
19264 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
19265 // debug statements here
19267 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
19269 export function ChainParameters_get_network(this_ptr: bigint): Network {
19270 if(!isWasmInitialized) {
19271 throw new Error("initializeWasm() must be awaited first!");
19273 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
19274 return nativeResponseValue;
19276 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
19278 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
19279 if(!isWasmInitialized) {
19280 throw new Error("initializeWasm() must be awaited first!");
19282 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
19283 // debug statements here
19285 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
19287 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
19288 if(!isWasmInitialized) {
19289 throw new Error("initializeWasm() must be awaited first!");
19291 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
19292 return nativeResponseValue;
19294 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
19296 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
19297 if(!isWasmInitialized) {
19298 throw new Error("initializeWasm() must be awaited first!");
19300 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
19301 // debug statements here
19303 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
19305 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
19306 if(!isWasmInitialized) {
19307 throw new Error("initializeWasm() must be awaited first!");
19309 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
19310 return nativeResponseValue;
19312 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
19314 export function ChainParameters_clone_ptr(arg: bigint): bigint {
19315 if(!isWasmInitialized) {
19316 throw new Error("initializeWasm() must be awaited first!");
19318 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
19319 return nativeResponseValue;
19321 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
19323 export function ChainParameters_clone(orig: bigint): bigint {
19324 if(!isWasmInitialized) {
19325 throw new Error("initializeWasm() must be awaited first!");
19327 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
19328 return nativeResponseValue;
19330 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
19332 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
19333 if(!isWasmInitialized) {
19334 throw new Error("initializeWasm() must be awaited first!");
19336 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
19337 // debug statements here
19339 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19341 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
19342 if(!isWasmInitialized) {
19343 throw new Error("initializeWasm() must be awaited first!");
19345 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
19346 return nativeResponseValue;
19348 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
19350 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
19351 if(!isWasmInitialized) {
19352 throw new Error("initializeWasm() must be awaited first!");
19354 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
19355 // debug statements here
19357 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19359 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
19360 if(!isWasmInitialized) {
19361 throw new Error("initializeWasm() must be awaited first!");
19363 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
19364 return nativeResponseValue;
19366 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
19368 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
19369 if(!isWasmInitialized) {
19370 throw new Error("initializeWasm() must be awaited first!");
19372 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
19373 // debug statements here
19375 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19377 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
19378 if(!isWasmInitialized) {
19379 throw new Error("initializeWasm() must be awaited first!");
19381 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
19382 return nativeResponseValue;
19384 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
19386 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
19387 if(!isWasmInitialized) {
19388 throw new Error("initializeWasm() must be awaited first!");
19390 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
19391 // debug statements here
19393 // 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);
19395 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
19396 if(!isWasmInitialized) {
19397 throw new Error("initializeWasm() must be awaited first!");
19399 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
19400 return nativeResponseValue;
19402 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
19404 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
19405 if(!isWasmInitialized) {
19406 throw new Error("initializeWasm() must be awaited first!");
19408 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
19409 return nativeResponseValue;
19411 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
19413 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
19414 if(!isWasmInitialized) {
19415 throw new Error("initializeWasm() must be awaited first!");
19417 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
19418 return nativeResponseValue;
19420 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
19422 export function ChannelCounterparty_free(this_obj: bigint): void {
19423 if(!isWasmInitialized) {
19424 throw new Error("initializeWasm() must be awaited first!");
19426 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
19427 // debug statements here
19429 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19431 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
19432 if(!isWasmInitialized) {
19433 throw new Error("initializeWasm() must be awaited first!");
19435 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
19436 return nativeResponseValue;
19438 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19440 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
19441 if(!isWasmInitialized) {
19442 throw new Error("initializeWasm() must be awaited first!");
19444 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
19445 // debug statements here
19447 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19449 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
19450 if(!isWasmInitialized) {
19451 throw new Error("initializeWasm() must be awaited first!");
19453 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
19454 return nativeResponseValue;
19456 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
19458 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
19459 if(!isWasmInitialized) {
19460 throw new Error("initializeWasm() must be awaited first!");
19462 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
19463 // debug statements here
19465 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19467 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
19468 if(!isWasmInitialized) {
19469 throw new Error("initializeWasm() must be awaited first!");
19471 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
19472 return nativeResponseValue;
19474 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
19476 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
19477 if(!isWasmInitialized) {
19478 throw new Error("initializeWasm() must be awaited first!");
19480 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
19481 // debug statements here
19483 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19485 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
19486 if(!isWasmInitialized) {
19487 throw new Error("initializeWasm() must be awaited first!");
19489 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
19490 return nativeResponseValue;
19492 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
19494 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
19495 if(!isWasmInitialized) {
19496 throw new Error("initializeWasm() must be awaited first!");
19498 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
19499 // debug statements here
19501 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19503 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
19504 if(!isWasmInitialized) {
19505 throw new Error("initializeWasm() must be awaited first!");
19507 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
19508 return nativeResponseValue;
19510 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19512 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
19513 if(!isWasmInitialized) {
19514 throw new Error("initializeWasm() must be awaited first!");
19516 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
19517 // debug statements here
19519 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19521 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
19522 if(!isWasmInitialized) {
19523 throw new Error("initializeWasm() must be awaited first!");
19525 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
19526 return nativeResponseValue;
19528 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19530 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
19531 if(!isWasmInitialized) {
19532 throw new Error("initializeWasm() must be awaited first!");
19534 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
19535 // debug statements here
19537 // 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);
19539 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 {
19540 if(!isWasmInitialized) {
19541 throw new Error("initializeWasm() must be awaited first!");
19543 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);
19544 return nativeResponseValue;
19546 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
19548 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
19549 if(!isWasmInitialized) {
19550 throw new Error("initializeWasm() must be awaited first!");
19552 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
19553 return nativeResponseValue;
19555 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
19557 export function ChannelCounterparty_clone(orig: bigint): bigint {
19558 if(!isWasmInitialized) {
19559 throw new Error("initializeWasm() must be awaited first!");
19561 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
19562 return nativeResponseValue;
19564 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
19566 export function ChannelDetails_free(this_obj: bigint): void {
19567 if(!isWasmInitialized) {
19568 throw new Error("initializeWasm() must be awaited first!");
19570 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
19571 // debug statements here
19573 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
19575 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
19576 if(!isWasmInitialized) {
19577 throw new Error("initializeWasm() must be awaited first!");
19579 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
19580 return nativeResponseValue;
19582 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19584 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
19585 if(!isWasmInitialized) {
19586 throw new Error("initializeWasm() must be awaited first!");
19588 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
19589 // debug statements here
19591 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19593 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
19594 if(!isWasmInitialized) {
19595 throw new Error("initializeWasm() must be awaited first!");
19597 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
19598 return nativeResponseValue;
19600 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
19602 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
19603 if(!isWasmInitialized) {
19604 throw new Error("initializeWasm() must be awaited first!");
19606 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
19607 // debug statements here
19609 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19611 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
19612 if(!isWasmInitialized) {
19613 throw new Error("initializeWasm() must be awaited first!");
19615 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
19616 return nativeResponseValue;
19618 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19620 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
19621 if(!isWasmInitialized) {
19622 throw new Error("initializeWasm() must be awaited first!");
19624 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
19625 // debug statements here
19627 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19629 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
19630 if(!isWasmInitialized) {
19631 throw new Error("initializeWasm() must be awaited first!");
19633 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
19634 return nativeResponseValue;
19636 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19638 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
19639 if(!isWasmInitialized) {
19640 throw new Error("initializeWasm() must be awaited first!");
19642 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
19643 // debug statements here
19645 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19647 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
19648 if(!isWasmInitialized) {
19649 throw new Error("initializeWasm() must be awaited first!");
19651 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
19652 return nativeResponseValue;
19654 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19656 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
19657 if(!isWasmInitialized) {
19658 throw new Error("initializeWasm() must be awaited first!");
19660 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
19661 // debug statements here
19663 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19665 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
19666 if(!isWasmInitialized) {
19667 throw new Error("initializeWasm() must be awaited first!");
19669 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
19670 return nativeResponseValue;
19672 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19674 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
19675 if(!isWasmInitialized) {
19676 throw new Error("initializeWasm() must be awaited first!");
19678 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
19679 // debug statements here
19681 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19683 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
19684 if(!isWasmInitialized) {
19685 throw new Error("initializeWasm() must be awaited first!");
19687 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
19688 return nativeResponseValue;
19690 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19692 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
19693 if(!isWasmInitialized) {
19694 throw new Error("initializeWasm() must be awaited first!");
19696 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
19697 // debug statements here
19699 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19701 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
19702 if(!isWasmInitialized) {
19703 throw new Error("initializeWasm() must be awaited first!");
19705 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
19706 return nativeResponseValue;
19708 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19710 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
19711 if(!isWasmInitialized) {
19712 throw new Error("initializeWasm() must be awaited first!");
19714 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
19715 // debug statements here
19717 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19719 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
19720 if(!isWasmInitialized) {
19721 throw new Error("initializeWasm() must be awaited first!");
19723 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
19724 return nativeResponseValue;
19726 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19728 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
19729 if(!isWasmInitialized) {
19730 throw new Error("initializeWasm() must be awaited first!");
19732 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
19733 // debug statements here
19735 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19737 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): bigint {
19738 if(!isWasmInitialized) {
19739 throw new Error("initializeWasm() must be awaited first!");
19741 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19742 return nativeResponseValue;
19744 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19746 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: bigint): void {
19747 if(!isWasmInitialized) {
19748 throw new Error("initializeWasm() must be awaited first!");
19750 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19751 // debug statements here
19753 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19755 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
19756 if(!isWasmInitialized) {
19757 throw new Error("initializeWasm() must be awaited first!");
19759 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19760 return nativeResponseValue;
19762 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19764 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
19765 if(!isWasmInitialized) {
19766 throw new Error("initializeWasm() must be awaited first!");
19768 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19769 // debug statements here
19771 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19773 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
19774 if(!isWasmInitialized) {
19775 throw new Error("initializeWasm() must be awaited first!");
19777 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19778 return nativeResponseValue;
19780 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19782 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
19783 if(!isWasmInitialized) {
19784 throw new Error("initializeWasm() must be awaited first!");
19786 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19787 // debug statements here
19789 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19791 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
19792 if(!isWasmInitialized) {
19793 throw new Error("initializeWasm() must be awaited first!");
19795 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19796 return nativeResponseValue;
19798 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19800 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
19801 if(!isWasmInitialized) {
19802 throw new Error("initializeWasm() must be awaited first!");
19804 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19805 // debug statements here
19807 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19809 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
19810 if(!isWasmInitialized) {
19811 throw new Error("initializeWasm() must be awaited first!");
19813 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19814 return nativeResponseValue;
19816 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19818 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
19819 if(!isWasmInitialized) {
19820 throw new Error("initializeWasm() must be awaited first!");
19822 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19823 // debug statements here
19825 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19827 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
19828 if(!isWasmInitialized) {
19829 throw new Error("initializeWasm() must be awaited first!");
19831 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19832 return nativeResponseValue;
19834 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19836 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
19837 if(!isWasmInitialized) {
19838 throw new Error("initializeWasm() must be awaited first!");
19840 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19841 // debug statements here
19843 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19845 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
19846 if(!isWasmInitialized) {
19847 throw new Error("initializeWasm() must be awaited first!");
19849 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19850 return nativeResponseValue;
19852 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19854 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
19855 if(!isWasmInitialized) {
19856 throw new Error("initializeWasm() must be awaited first!");
19858 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19859 // debug statements here
19861 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19863 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
19864 if(!isWasmInitialized) {
19865 throw new Error("initializeWasm() must be awaited first!");
19867 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19868 return nativeResponseValue;
19870 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19872 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
19873 if(!isWasmInitialized) {
19874 throw new Error("initializeWasm() must be awaited first!");
19876 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19877 // debug statements here
19879 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19881 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
19882 if(!isWasmInitialized) {
19883 throw new Error("initializeWasm() must be awaited first!");
19885 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19886 return nativeResponseValue;
19888 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19890 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
19891 if(!isWasmInitialized) {
19892 throw new Error("initializeWasm() must be awaited first!");
19894 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19895 // debug statements here
19897 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19899 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
19900 if(!isWasmInitialized) {
19901 throw new Error("initializeWasm() must be awaited first!");
19903 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19904 return nativeResponseValue;
19906 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19908 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
19909 if(!isWasmInitialized) {
19910 throw new Error("initializeWasm() must be awaited first!");
19912 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19913 // debug statements here
19915 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19917 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
19918 if(!isWasmInitialized) {
19919 throw new Error("initializeWasm() must be awaited first!");
19921 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19922 return nativeResponseValue;
19924 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19926 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
19927 if(!isWasmInitialized) {
19928 throw new Error("initializeWasm() must be awaited first!");
19930 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19931 // debug statements here
19933 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19935 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
19936 if(!isWasmInitialized) {
19937 throw new Error("initializeWasm() must be awaited first!");
19939 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19940 return nativeResponseValue;
19942 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19944 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
19945 if(!isWasmInitialized) {
19946 throw new Error("initializeWasm() must be awaited first!");
19948 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19949 // debug statements here
19951 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19953 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
19954 if(!isWasmInitialized) {
19955 throw new Error("initializeWasm() must be awaited first!");
19957 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19958 return nativeResponseValue;
19960 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19962 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
19963 if(!isWasmInitialized) {
19964 throw new Error("initializeWasm() must be awaited first!");
19966 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19967 // debug statements here
19969 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19971 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
19972 if(!isWasmInitialized) {
19973 throw new Error("initializeWasm() must be awaited first!");
19975 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
19976 return nativeResponseValue;
19978 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19980 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
19981 if(!isWasmInitialized) {
19982 throw new Error("initializeWasm() must be awaited first!");
19984 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
19985 // debug statements here
19987 // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
19989 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
19990 if(!isWasmInitialized) {
19991 throw new Error("initializeWasm() must be awaited first!");
19993 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
19994 return nativeResponseValue;
19996 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19998 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
19999 if(!isWasmInitialized) {
20000 throw new Error("initializeWasm() must be awaited first!");
20002 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
20003 return nativeResponseValue;
20005 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
20007 export function ChannelDetails_clone(orig: bigint): bigint {
20008 if(!isWasmInitialized) {
20009 throw new Error("initializeWasm() must be awaited first!");
20011 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
20012 return nativeResponseValue;
20014 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
20016 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
20017 if(!isWasmInitialized) {
20018 throw new Error("initializeWasm() must be awaited first!");
20020 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
20021 return nativeResponseValue;
20023 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
20025 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
20026 if(!isWasmInitialized) {
20027 throw new Error("initializeWasm() must be awaited first!");
20029 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
20030 return nativeResponseValue;
20032 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
20034 export function PaymentSendFailure_free(this_ptr: bigint): void {
20035 if(!isWasmInitialized) {
20036 throw new Error("initializeWasm() must be awaited first!");
20038 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
20039 // debug statements here
20041 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
20043 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
20044 if(!isWasmInitialized) {
20045 throw new Error("initializeWasm() must be awaited first!");
20047 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
20048 return nativeResponseValue;
20050 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
20052 export function PaymentSendFailure_clone(orig: bigint): bigint {
20053 if(!isWasmInitialized) {
20054 throw new Error("initializeWasm() must be awaited first!");
20056 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
20057 return nativeResponseValue;
20059 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
20061 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
20062 if(!isWasmInitialized) {
20063 throw new Error("initializeWasm() must be awaited first!");
20065 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
20066 return nativeResponseValue;
20068 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
20070 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
20071 if(!isWasmInitialized) {
20072 throw new Error("initializeWasm() must be awaited first!");
20074 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
20075 return nativeResponseValue;
20077 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
20079 export function PaymentSendFailure_all_failed_retry_safe(a: number): bigint {
20080 if(!isWasmInitialized) {
20081 throw new Error("initializeWasm() must be awaited first!");
20083 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
20084 return nativeResponseValue;
20086 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
20088 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
20089 if(!isWasmInitialized) {
20090 throw new Error("initializeWasm() must be awaited first!");
20092 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
20093 return nativeResponseValue;
20095 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
20097 export function PhantomRouteHints_free(this_obj: bigint): void {
20098 if(!isWasmInitialized) {
20099 throw new Error("initializeWasm() must be awaited first!");
20101 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
20102 // debug statements here
20104 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20106 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
20107 if(!isWasmInitialized) {
20108 throw new Error("initializeWasm() must be awaited first!");
20110 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
20111 return nativeResponseValue;
20113 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
20115 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
20116 if(!isWasmInitialized) {
20117 throw new Error("initializeWasm() must be awaited first!");
20119 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
20120 // debug statements here
20122 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20124 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
20125 if(!isWasmInitialized) {
20126 throw new Error("initializeWasm() must be awaited first!");
20128 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
20129 return nativeResponseValue;
20131 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
20133 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
20134 if(!isWasmInitialized) {
20135 throw new Error("initializeWasm() must be awaited first!");
20137 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
20138 // debug statements here
20140 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20142 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
20143 if(!isWasmInitialized) {
20144 throw new Error("initializeWasm() must be awaited first!");
20146 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
20147 return nativeResponseValue;
20149 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20151 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
20152 if(!isWasmInitialized) {
20153 throw new Error("initializeWasm() must be awaited first!");
20155 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
20156 // debug statements here
20158 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
20160 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
20161 if(!isWasmInitialized) {
20162 throw new Error("initializeWasm() must be awaited first!");
20164 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
20165 return nativeResponseValue;
20167 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
20169 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
20170 if(!isWasmInitialized) {
20171 throw new Error("initializeWasm() must be awaited first!");
20173 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
20174 return nativeResponseValue;
20176 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
20178 export function PhantomRouteHints_clone(orig: bigint): bigint {
20179 if(!isWasmInitialized) {
20180 throw new Error("initializeWasm() must be awaited first!");
20182 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
20183 return nativeResponseValue;
20185 // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params);
20187 export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, keys_manager: bigint, config: bigint, params: bigint): bigint {
20188 if(!isWasmInitialized) {
20189 throw new Error("initializeWasm() must be awaited first!");
20191 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
20192 return nativeResponseValue;
20194 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
20196 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
20197 if(!isWasmInitialized) {
20198 throw new Error("initializeWasm() must be awaited first!");
20200 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
20201 return nativeResponseValue;
20203 // MUST_USE_RES struct LDKCResult__u832APIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_channel_id, struct LDKUserConfig override_config);
20205 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: bigint, override_config: bigint): bigint {
20206 if(!isWasmInitialized) {
20207 throw new Error("initializeWasm() must be awaited first!");
20209 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
20210 return nativeResponseValue;
20212 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
20214 export function ChannelManager_list_channels(this_arg: bigint): number {
20215 if(!isWasmInitialized) {
20216 throw new Error("initializeWasm() must be awaited first!");
20218 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
20219 return nativeResponseValue;
20221 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
20223 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
20224 if(!isWasmInitialized) {
20225 throw new Error("initializeWasm() must be awaited first!");
20227 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
20228 return nativeResponseValue;
20230 // 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);
20232 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
20233 if(!isWasmInitialized) {
20234 throw new Error("initializeWasm() must be awaited first!");
20236 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
20237 return nativeResponseValue;
20239 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_target_feerate(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id, uint32_t target_feerate_sats_per_1000_weight);
20241 export function ChannelManager_close_channel_with_target_feerate(this_arg: bigint, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: number): bigint {
20242 if(!isWasmInitialized) {
20243 throw new Error("initializeWasm() must be awaited first!");
20245 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
20246 return nativeResponseValue;
20248 // 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);
20250 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
20251 if(!isWasmInitialized) {
20252 throw new Error("initializeWasm() must be awaited first!");
20254 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
20255 return nativeResponseValue;
20257 // 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);
20259 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
20260 if(!isWasmInitialized) {
20261 throw new Error("initializeWasm() must be awaited first!");
20263 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
20264 return nativeResponseValue;
20266 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
20268 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
20269 if(!isWasmInitialized) {
20270 throw new Error("initializeWasm() must be awaited first!");
20272 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
20273 // debug statements here
20275 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
20277 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
20278 if(!isWasmInitialized) {
20279 throw new Error("initializeWasm() must be awaited first!");
20281 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
20282 // debug statements here
20284 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
20286 export function ChannelManager_send_payment(this_arg: bigint, route: bigint, payment_hash: number, payment_secret: number): bigint {
20287 if(!isWasmInitialized) {
20288 throw new Error("initializeWasm() must be awaited first!");
20290 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
20291 return nativeResponseValue;
20293 // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_retry_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id);
20295 export function ChannelManager_retry_payment(this_arg: bigint, route: bigint, payment_id: number): bigint {
20296 if(!isWasmInitialized) {
20297 throw new Error("initializeWasm() must be awaited first!");
20299 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
20300 return nativeResponseValue;
20302 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
20304 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
20305 if(!isWasmInitialized) {
20306 throw new Error("initializeWasm() must be awaited first!");
20308 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
20309 // debug statements here
20311 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
20313 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: number): bigint {
20314 if(!isWasmInitialized) {
20315 throw new Error("initializeWasm() must be awaited first!");
20317 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
20318 return nativeResponseValue;
20320 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
20322 export function ChannelManager_send_probe(this_arg: bigint, hops: number): bigint {
20323 if(!isWasmInitialized) {
20324 throw new Error("initializeWasm() must be awaited first!");
20326 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
20327 return nativeResponseValue;
20329 // 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);
20331 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
20332 if(!isWasmInitialized) {
20333 throw new Error("initializeWasm() must be awaited first!");
20335 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
20336 return nativeResponseValue;
20338 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
20340 export function ChannelManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
20341 if(!isWasmInitialized) {
20342 throw new Error("initializeWasm() must be awaited first!");
20344 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
20345 // debug statements here
20347 // 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);
20349 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
20350 if(!isWasmInitialized) {
20351 throw new Error("initializeWasm() must be awaited first!");
20353 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
20354 return nativeResponseValue;
20356 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
20358 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
20359 if(!isWasmInitialized) {
20360 throw new Error("initializeWasm() must be awaited first!");
20362 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
20363 // debug statements here
20365 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
20367 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
20368 if(!isWasmInitialized) {
20369 throw new Error("initializeWasm() must be awaited first!");
20371 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
20372 // debug statements here
20374 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
20376 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
20377 if(!isWasmInitialized) {
20378 throw new Error("initializeWasm() must be awaited first!");
20380 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
20381 // debug statements here
20383 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
20385 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
20386 if(!isWasmInitialized) {
20387 throw new Error("initializeWasm() must be awaited first!");
20389 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
20390 // debug statements here
20392 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
20394 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
20395 if(!isWasmInitialized) {
20396 throw new Error("initializeWasm() must be awaited first!");
20398 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
20399 return nativeResponseValue;
20401 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, uint64_t user_channel_id);
20403 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): bigint {
20404 if(!isWasmInitialized) {
20405 throw new Error("initializeWasm() must be awaited first!");
20407 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
20408 return nativeResponseValue;
20410 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, uint64_t user_channel_id);
20412 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): bigint {
20413 if(!isWasmInitialized) {
20414 throw new Error("initializeWasm() must be awaited first!");
20416 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
20417 return nativeResponseValue;
20419 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ ChannelManager_create_inbound_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
20421 export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
20422 if(!isWasmInitialized) {
20423 throw new Error("initializeWasm() must be awaited first!");
20425 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
20426 return nativeResponseValue;
20428 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ ChannelManager_create_inbound_payment_legacy(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
20430 export function ChannelManager_create_inbound_payment_legacy(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
20431 if(!isWasmInitialized) {
20432 throw new Error("initializeWasm() must be awaited first!");
20434 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
20435 return nativeResponseValue;
20437 // MUST_USE_RES struct LDKCResult_PaymentSecretNoneZ ChannelManager_create_inbound_payment_for_hash(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
20439 export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
20440 if(!isWasmInitialized) {
20441 throw new Error("initializeWasm() must be awaited first!");
20443 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
20444 return nativeResponseValue;
20446 // MUST_USE_RES struct LDKCResult_PaymentSecretAPIErrorZ ChannelManager_create_inbound_payment_for_hash_legacy(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
20448 export function ChannelManager_create_inbound_payment_for_hash_legacy(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number): bigint {
20449 if(!isWasmInitialized) {
20450 throw new Error("initializeWasm() must be awaited first!");
20452 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
20453 return nativeResponseValue;
20455 // MUST_USE_RES struct LDKCResult_PaymentPreimageAPIErrorZ ChannelManager_get_payment_preimage(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
20457 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
20458 if(!isWasmInitialized) {
20459 throw new Error("initializeWasm() must be awaited first!");
20461 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
20462 return nativeResponseValue;
20464 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
20466 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
20467 if(!isWasmInitialized) {
20468 throw new Error("initializeWasm() must be awaited first!");
20470 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
20471 return nativeResponseValue;
20473 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
20475 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
20476 if(!isWasmInitialized) {
20477 throw new Error("initializeWasm() must be awaited first!");
20479 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
20480 return nativeResponseValue;
20482 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
20484 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
20485 if(!isWasmInitialized) {
20486 throw new Error("initializeWasm() must be awaited first!");
20488 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
20489 return nativeResponseValue;
20491 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
20493 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
20494 if(!isWasmInitialized) {
20495 throw new Error("initializeWasm() must be awaited first!");
20497 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
20498 return nativeResponseValue;
20500 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
20502 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
20503 if(!isWasmInitialized) {
20504 throw new Error("initializeWasm() must be awaited first!");
20506 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
20507 return nativeResponseValue;
20509 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
20511 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
20512 if(!isWasmInitialized) {
20513 throw new Error("initializeWasm() must be awaited first!");
20515 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
20516 return nativeResponseValue;
20518 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
20520 export function ChannelManager_await_persistable_update(this_arg: bigint): void {
20521 if(!isWasmInitialized) {
20522 throw new Error("initializeWasm() must be awaited first!");
20524 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
20525 // debug statements here
20527 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
20529 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
20530 if(!isWasmInitialized) {
20531 throw new Error("initializeWasm() must be awaited first!");
20533 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
20534 return nativeResponseValue;
20536 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
20538 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
20539 if(!isWasmInitialized) {
20540 throw new Error("initializeWasm() must be awaited first!");
20542 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
20543 return nativeResponseValue;
20545 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
20547 export function CounterpartyForwardingInfo_write(obj: bigint): number {
20548 if(!isWasmInitialized) {
20549 throw new Error("initializeWasm() must be awaited first!");
20551 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
20552 return nativeResponseValue;
20554 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
20556 export function CounterpartyForwardingInfo_read(ser: number): bigint {
20557 if(!isWasmInitialized) {
20558 throw new Error("initializeWasm() must be awaited first!");
20560 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
20561 return nativeResponseValue;
20563 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
20565 export function ChannelCounterparty_write(obj: bigint): number {
20566 if(!isWasmInitialized) {
20567 throw new Error("initializeWasm() must be awaited first!");
20569 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
20570 return nativeResponseValue;
20572 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
20574 export function ChannelCounterparty_read(ser: number): bigint {
20575 if(!isWasmInitialized) {
20576 throw new Error("initializeWasm() must be awaited first!");
20578 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
20579 return nativeResponseValue;
20581 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
20583 export function ChannelDetails_write(obj: bigint): number {
20584 if(!isWasmInitialized) {
20585 throw new Error("initializeWasm() must be awaited first!");
20587 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
20588 return nativeResponseValue;
20590 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
20592 export function ChannelDetails_read(ser: number): bigint {
20593 if(!isWasmInitialized) {
20594 throw new Error("initializeWasm() must be awaited first!");
20596 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
20597 return nativeResponseValue;
20599 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
20601 export function PhantomRouteHints_write(obj: bigint): number {
20602 if(!isWasmInitialized) {
20603 throw new Error("initializeWasm() must be awaited first!");
20605 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
20606 return nativeResponseValue;
20608 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
20610 export function PhantomRouteHints_read(ser: number): bigint {
20611 if(!isWasmInitialized) {
20612 throw new Error("initializeWasm() must be awaited first!");
20614 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
20615 return nativeResponseValue;
20617 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
20619 export function ChannelManager_write(obj: bigint): number {
20620 if(!isWasmInitialized) {
20621 throw new Error("initializeWasm() must be awaited first!");
20623 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
20624 return nativeResponseValue;
20626 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
20628 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
20629 if(!isWasmInitialized) {
20630 throw new Error("initializeWasm() must be awaited first!");
20632 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
20633 // debug statements here
20635 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20637 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: bigint): bigint {
20638 if(!isWasmInitialized) {
20639 throw new Error("initializeWasm() must be awaited first!");
20641 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
20642 return nativeResponseValue;
20644 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
20646 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: bigint, val: bigint): void {
20647 if(!isWasmInitialized) {
20648 throw new Error("initializeWasm() must be awaited first!");
20650 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
20651 // debug statements here
20653 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20655 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
20656 if(!isWasmInitialized) {
20657 throw new Error("initializeWasm() must be awaited first!");
20659 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
20660 return nativeResponseValue;
20662 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
20664 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
20665 if(!isWasmInitialized) {
20666 throw new Error("initializeWasm() must be awaited first!");
20668 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
20669 // debug statements here
20671 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20673 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
20674 if(!isWasmInitialized) {
20675 throw new Error("initializeWasm() must be awaited first!");
20677 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
20678 return nativeResponseValue;
20680 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
20682 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
20683 if(!isWasmInitialized) {
20684 throw new Error("initializeWasm() must be awaited first!");
20686 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
20687 // debug statements here
20689 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20691 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
20692 if(!isWasmInitialized) {
20693 throw new Error("initializeWasm() must be awaited first!");
20695 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
20696 return nativeResponseValue;
20698 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
20700 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
20701 if(!isWasmInitialized) {
20702 throw new Error("initializeWasm() must be awaited first!");
20704 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
20705 // debug statements here
20707 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20709 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
20710 if(!isWasmInitialized) {
20711 throw new Error("initializeWasm() must be awaited first!");
20713 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
20714 return nativeResponseValue;
20716 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
20718 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
20719 if(!isWasmInitialized) {
20720 throw new Error("initializeWasm() must be awaited first!");
20722 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
20723 // debug statements here
20725 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20727 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
20728 if(!isWasmInitialized) {
20729 throw new Error("initializeWasm() must be awaited first!");
20731 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
20732 return nativeResponseValue;
20734 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
20736 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
20737 if(!isWasmInitialized) {
20738 throw new Error("initializeWasm() must be awaited first!");
20740 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
20741 // debug statements here
20743 // MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKKeysInterface keys_manager, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
20745 export function ChannelManagerReadArgs_new(keys_manager: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
20746 if(!isWasmInitialized) {
20747 throw new Error("initializeWasm() must be awaited first!");
20749 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
20750 return nativeResponseValue;
20752 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
20754 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: bigint): bigint {
20755 if(!isWasmInitialized) {
20756 throw new Error("initializeWasm() must be awaited first!");
20758 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
20759 return nativeResponseValue;
20761 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
20763 export function ExpandedKey_free(this_obj: bigint): void {
20764 if(!isWasmInitialized) {
20765 throw new Error("initializeWasm() must be awaited first!");
20767 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
20768 // debug statements here
20770 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
20772 export function ExpandedKey_new(key_material: number): bigint {
20773 if(!isWasmInitialized) {
20774 throw new Error("initializeWasm() must be awaited first!");
20776 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
20777 return nativeResponseValue;
20779 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ create(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, const struct LDKKeysInterface *NONNULL_PTR keys_manager, uint64_t current_time);
20781 export function create(keys: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, keys_manager: bigint, current_time: bigint): bigint {
20782 if(!isWasmInitialized) {
20783 throw new Error("initializeWasm() must be awaited first!");
20785 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
20786 return nativeResponseValue;
20788 // struct LDKCResult_PaymentSecretNoneZ create_from_hash(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, struct LDKThirtyTwoBytes payment_hash, uint32_t invoice_expiry_delta_secs, uint64_t current_time);
20790 export function create_from_hash(keys: bigint, min_value_msat: bigint, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): bigint {
20791 if(!isWasmInitialized) {
20792 throw new Error("initializeWasm() must be awaited first!");
20794 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20795 return nativeResponseValue;
20797 // void DecodeError_free(struct LDKDecodeError this_obj);
20799 export function DecodeError_free(this_obj: bigint): void {
20800 if(!isWasmInitialized) {
20801 throw new Error("initializeWasm() must be awaited first!");
20803 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20804 // debug statements here
20806 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20808 export function DecodeError_clone_ptr(arg: bigint): bigint {
20809 if(!isWasmInitialized) {
20810 throw new Error("initializeWasm() must be awaited first!");
20812 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20813 return nativeResponseValue;
20815 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20817 export function DecodeError_clone(orig: bigint): bigint {
20818 if(!isWasmInitialized) {
20819 throw new Error("initializeWasm() must be awaited first!");
20821 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20822 return nativeResponseValue;
20824 // void Init_free(struct LDKInit this_obj);
20826 export function Init_free(this_obj: bigint): void {
20827 if(!isWasmInitialized) {
20828 throw new Error("initializeWasm() must be awaited first!");
20830 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20831 // debug statements here
20833 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20835 export function Init_get_features(this_ptr: bigint): bigint {
20836 if(!isWasmInitialized) {
20837 throw new Error("initializeWasm() must be awaited first!");
20839 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20840 return nativeResponseValue;
20842 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20844 export function Init_set_features(this_ptr: bigint, val: bigint): void {
20845 if(!isWasmInitialized) {
20846 throw new Error("initializeWasm() must be awaited first!");
20848 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20849 // debug statements here
20851 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20853 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
20854 if(!isWasmInitialized) {
20855 throw new Error("initializeWasm() must be awaited first!");
20857 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20858 return nativeResponseValue;
20860 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20862 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
20863 if(!isWasmInitialized) {
20864 throw new Error("initializeWasm() must be awaited first!");
20866 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20867 // debug statements here
20869 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20871 export function Init_new(features_arg: bigint, remote_network_address_arg: bigint): bigint {
20872 if(!isWasmInitialized) {
20873 throw new Error("initializeWasm() must be awaited first!");
20875 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20876 return nativeResponseValue;
20878 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20880 export function Init_clone_ptr(arg: bigint): bigint {
20881 if(!isWasmInitialized) {
20882 throw new Error("initializeWasm() must be awaited first!");
20884 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20885 return nativeResponseValue;
20887 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20889 export function Init_clone(orig: bigint): bigint {
20890 if(!isWasmInitialized) {
20891 throw new Error("initializeWasm() must be awaited first!");
20893 const nativeResponseValue = wasm.TS_Init_clone(orig);
20894 return nativeResponseValue;
20896 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20898 export function ErrorMessage_free(this_obj: bigint): void {
20899 if(!isWasmInitialized) {
20900 throw new Error("initializeWasm() must be awaited first!");
20902 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20903 // debug statements here
20905 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20907 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
20908 if(!isWasmInitialized) {
20909 throw new Error("initializeWasm() must be awaited first!");
20911 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20912 return nativeResponseValue;
20914 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20916 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
20917 if(!isWasmInitialized) {
20918 throw new Error("initializeWasm() must be awaited first!");
20920 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20921 // debug statements here
20923 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20925 export function ErrorMessage_get_data(this_ptr: bigint): number {
20926 if(!isWasmInitialized) {
20927 throw new Error("initializeWasm() must be awaited first!");
20929 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20930 return nativeResponseValue;
20932 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20934 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
20935 if(!isWasmInitialized) {
20936 throw new Error("initializeWasm() must be awaited first!");
20938 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20939 // debug statements here
20941 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20943 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
20944 if(!isWasmInitialized) {
20945 throw new Error("initializeWasm() must be awaited first!");
20947 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20948 return nativeResponseValue;
20950 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20952 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
20953 if(!isWasmInitialized) {
20954 throw new Error("initializeWasm() must be awaited first!");
20956 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20957 return nativeResponseValue;
20959 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20961 export function ErrorMessage_clone(orig: bigint): bigint {
20962 if(!isWasmInitialized) {
20963 throw new Error("initializeWasm() must be awaited first!");
20965 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20966 return nativeResponseValue;
20968 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20970 export function WarningMessage_free(this_obj: bigint): void {
20971 if(!isWasmInitialized) {
20972 throw new Error("initializeWasm() must be awaited first!");
20974 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20975 // debug statements here
20977 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20979 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
20980 if(!isWasmInitialized) {
20981 throw new Error("initializeWasm() must be awaited first!");
20983 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20984 return nativeResponseValue;
20986 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20988 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
20989 if(!isWasmInitialized) {
20990 throw new Error("initializeWasm() must be awaited first!");
20992 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20993 // debug statements here
20995 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20997 export function WarningMessage_get_data(this_ptr: bigint): number {
20998 if(!isWasmInitialized) {
20999 throw new Error("initializeWasm() must be awaited first!");
21001 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
21002 return nativeResponseValue;
21004 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
21006 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
21007 if(!isWasmInitialized) {
21008 throw new Error("initializeWasm() must be awaited first!");
21010 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
21011 // debug statements here
21013 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
21015 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
21016 if(!isWasmInitialized) {
21017 throw new Error("initializeWasm() must be awaited first!");
21019 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
21020 return nativeResponseValue;
21022 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
21024 export function WarningMessage_clone_ptr(arg: bigint): bigint {
21025 if(!isWasmInitialized) {
21026 throw new Error("initializeWasm() must be awaited first!");
21028 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
21029 return nativeResponseValue;
21031 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
21033 export function WarningMessage_clone(orig: bigint): bigint {
21034 if(!isWasmInitialized) {
21035 throw new Error("initializeWasm() must be awaited first!");
21037 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
21038 return nativeResponseValue;
21040 // void Ping_free(struct LDKPing this_obj);
21042 export function Ping_free(this_obj: bigint): void {
21043 if(!isWasmInitialized) {
21044 throw new Error("initializeWasm() must be awaited first!");
21046 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
21047 // debug statements here
21049 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
21051 export function Ping_get_ponglen(this_ptr: bigint): number {
21052 if(!isWasmInitialized) {
21053 throw new Error("initializeWasm() must be awaited first!");
21055 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
21056 return nativeResponseValue;
21058 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
21060 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
21061 if(!isWasmInitialized) {
21062 throw new Error("initializeWasm() must be awaited first!");
21064 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
21065 // debug statements here
21067 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
21069 export function Ping_get_byteslen(this_ptr: bigint): number {
21070 if(!isWasmInitialized) {
21071 throw new Error("initializeWasm() must be awaited first!");
21073 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
21074 return nativeResponseValue;
21076 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
21078 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
21079 if(!isWasmInitialized) {
21080 throw new Error("initializeWasm() must be awaited first!");
21082 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
21083 // debug statements here
21085 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
21087 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
21088 if(!isWasmInitialized) {
21089 throw new Error("initializeWasm() must be awaited first!");
21091 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
21092 return nativeResponseValue;
21094 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
21096 export function Ping_clone_ptr(arg: bigint): bigint {
21097 if(!isWasmInitialized) {
21098 throw new Error("initializeWasm() must be awaited first!");
21100 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
21101 return nativeResponseValue;
21103 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
21105 export function Ping_clone(orig: bigint): bigint {
21106 if(!isWasmInitialized) {
21107 throw new Error("initializeWasm() must be awaited first!");
21109 const nativeResponseValue = wasm.TS_Ping_clone(orig);
21110 return nativeResponseValue;
21112 // void Pong_free(struct LDKPong this_obj);
21114 export function Pong_free(this_obj: bigint): void {
21115 if(!isWasmInitialized) {
21116 throw new Error("initializeWasm() must be awaited first!");
21118 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
21119 // debug statements here
21121 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
21123 export function Pong_get_byteslen(this_ptr: bigint): number {
21124 if(!isWasmInitialized) {
21125 throw new Error("initializeWasm() must be awaited first!");
21127 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
21128 return nativeResponseValue;
21130 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
21132 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
21133 if(!isWasmInitialized) {
21134 throw new Error("initializeWasm() must be awaited first!");
21136 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
21137 // debug statements here
21139 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
21141 export function Pong_new(byteslen_arg: number): bigint {
21142 if(!isWasmInitialized) {
21143 throw new Error("initializeWasm() must be awaited first!");
21145 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
21146 return nativeResponseValue;
21148 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
21150 export function Pong_clone_ptr(arg: bigint): bigint {
21151 if(!isWasmInitialized) {
21152 throw new Error("initializeWasm() must be awaited first!");
21154 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
21155 return nativeResponseValue;
21157 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
21159 export function Pong_clone(orig: bigint): bigint {
21160 if(!isWasmInitialized) {
21161 throw new Error("initializeWasm() must be awaited first!");
21163 const nativeResponseValue = wasm.TS_Pong_clone(orig);
21164 return nativeResponseValue;
21166 // void OpenChannel_free(struct LDKOpenChannel this_obj);
21168 export function OpenChannel_free(this_obj: bigint): void {
21169 if(!isWasmInitialized) {
21170 throw new Error("initializeWasm() must be awaited first!");
21172 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
21173 // debug statements here
21175 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
21177 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
21178 if(!isWasmInitialized) {
21179 throw new Error("initializeWasm() must be awaited first!");
21181 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
21182 return nativeResponseValue;
21184 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21186 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
21187 if(!isWasmInitialized) {
21188 throw new Error("initializeWasm() must be awaited first!");
21190 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
21191 // debug statements here
21193 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
21195 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
21196 if(!isWasmInitialized) {
21197 throw new Error("initializeWasm() must be awaited first!");
21199 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
21200 return nativeResponseValue;
21202 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21204 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
21205 if(!isWasmInitialized) {
21206 throw new Error("initializeWasm() must be awaited first!");
21208 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
21209 // debug statements here
21211 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21213 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
21214 if(!isWasmInitialized) {
21215 throw new Error("initializeWasm() must be awaited first!");
21217 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
21218 return nativeResponseValue;
21220 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21222 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
21223 if(!isWasmInitialized) {
21224 throw new Error("initializeWasm() must be awaited first!");
21226 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
21227 // debug statements here
21229 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21231 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
21232 if(!isWasmInitialized) {
21233 throw new Error("initializeWasm() must be awaited first!");
21235 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
21236 return nativeResponseValue;
21238 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21240 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
21241 if(!isWasmInitialized) {
21242 throw new Error("initializeWasm() must be awaited first!");
21244 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
21245 // debug statements here
21247 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21249 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
21250 if(!isWasmInitialized) {
21251 throw new Error("initializeWasm() must be awaited first!");
21253 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
21254 return nativeResponseValue;
21256 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21258 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
21259 if(!isWasmInitialized) {
21260 throw new Error("initializeWasm() must be awaited first!");
21262 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
21263 // debug statements here
21265 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21267 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
21268 if(!isWasmInitialized) {
21269 throw new Error("initializeWasm() must be awaited first!");
21271 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21272 return nativeResponseValue;
21274 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21276 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
21277 if(!isWasmInitialized) {
21278 throw new Error("initializeWasm() must be awaited first!");
21280 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21281 // debug statements here
21283 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21285 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
21286 if(!isWasmInitialized) {
21287 throw new Error("initializeWasm() must be awaited first!");
21289 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
21290 return nativeResponseValue;
21292 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21294 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
21295 if(!isWasmInitialized) {
21296 throw new Error("initializeWasm() must be awaited first!");
21298 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
21299 // debug statements here
21301 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21303 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
21304 if(!isWasmInitialized) {
21305 throw new Error("initializeWasm() must be awaited first!");
21307 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
21308 return nativeResponseValue;
21310 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21312 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
21313 if(!isWasmInitialized) {
21314 throw new Error("initializeWasm() must be awaited first!");
21316 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
21317 // debug statements here
21319 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21321 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
21322 if(!isWasmInitialized) {
21323 throw new Error("initializeWasm() must be awaited first!");
21325 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
21326 return nativeResponseValue;
21328 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
21330 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
21331 if(!isWasmInitialized) {
21332 throw new Error("initializeWasm() must be awaited first!");
21334 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
21335 // debug statements here
21337 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21339 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
21340 if(!isWasmInitialized) {
21341 throw new Error("initializeWasm() must be awaited first!");
21343 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
21344 return nativeResponseValue;
21346 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
21348 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
21349 if(!isWasmInitialized) {
21350 throw new Error("initializeWasm() must be awaited first!");
21352 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
21353 // debug statements here
21355 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21357 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
21358 if(!isWasmInitialized) {
21359 throw new Error("initializeWasm() must be awaited first!");
21361 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
21362 return nativeResponseValue;
21364 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
21366 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
21367 if(!isWasmInitialized) {
21368 throw new Error("initializeWasm() must be awaited first!");
21370 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
21371 // debug statements here
21373 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21375 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
21376 if(!isWasmInitialized) {
21377 throw new Error("initializeWasm() must be awaited first!");
21379 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
21380 return nativeResponseValue;
21382 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21384 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
21385 if(!isWasmInitialized) {
21386 throw new Error("initializeWasm() must be awaited first!");
21388 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
21389 // debug statements here
21391 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21393 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
21394 if(!isWasmInitialized) {
21395 throw new Error("initializeWasm() must be awaited first!");
21397 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
21398 return nativeResponseValue;
21400 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21402 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
21403 if(!isWasmInitialized) {
21404 throw new Error("initializeWasm() must be awaited first!");
21406 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
21407 // debug statements here
21409 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21411 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
21412 if(!isWasmInitialized) {
21413 throw new Error("initializeWasm() must be awaited first!");
21415 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
21416 return nativeResponseValue;
21418 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21420 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
21421 if(!isWasmInitialized) {
21422 throw new Error("initializeWasm() must be awaited first!");
21424 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
21425 // debug statements here
21427 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21429 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
21430 if(!isWasmInitialized) {
21431 throw new Error("initializeWasm() must be awaited first!");
21433 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
21434 return nativeResponseValue;
21436 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21438 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
21439 if(!isWasmInitialized) {
21440 throw new Error("initializeWasm() must be awaited first!");
21442 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
21443 // debug statements here
21445 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21447 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
21448 if(!isWasmInitialized) {
21449 throw new Error("initializeWasm() must be awaited first!");
21451 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
21452 return nativeResponseValue;
21454 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21456 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
21457 if(!isWasmInitialized) {
21458 throw new Error("initializeWasm() must be awaited first!");
21460 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
21461 // debug statements here
21463 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21465 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
21466 if(!isWasmInitialized) {
21467 throw new Error("initializeWasm() must be awaited first!");
21469 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
21470 return nativeResponseValue;
21472 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21474 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
21475 if(!isWasmInitialized) {
21476 throw new Error("initializeWasm() must be awaited first!");
21478 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
21479 // debug statements here
21481 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21483 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
21484 if(!isWasmInitialized) {
21485 throw new Error("initializeWasm() must be awaited first!");
21487 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
21488 return nativeResponseValue;
21490 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
21492 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
21493 if(!isWasmInitialized) {
21494 throw new Error("initializeWasm() must be awaited first!");
21496 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
21497 // debug statements here
21499 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21501 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
21502 if(!isWasmInitialized) {
21503 throw new Error("initializeWasm() must be awaited first!");
21505 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
21506 return nativeResponseValue;
21508 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21510 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
21511 if(!isWasmInitialized) {
21512 throw new Error("initializeWasm() must be awaited first!");
21514 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
21515 // debug statements here
21517 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
21519 export function OpenChannel_clone_ptr(arg: bigint): bigint {
21520 if(!isWasmInitialized) {
21521 throw new Error("initializeWasm() must be awaited first!");
21523 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
21524 return nativeResponseValue;
21526 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
21528 export function OpenChannel_clone(orig: bigint): bigint {
21529 if(!isWasmInitialized) {
21530 throw new Error("initializeWasm() must be awaited first!");
21532 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
21533 return nativeResponseValue;
21535 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
21537 export function AcceptChannel_free(this_obj: bigint): void {
21538 if(!isWasmInitialized) {
21539 throw new Error("initializeWasm() must be awaited first!");
21541 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
21542 // debug statements here
21544 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
21546 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
21547 if(!isWasmInitialized) {
21548 throw new Error("initializeWasm() must be awaited first!");
21550 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
21551 return nativeResponseValue;
21553 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21555 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
21556 if(!isWasmInitialized) {
21557 throw new Error("initializeWasm() must be awaited first!");
21559 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
21560 // debug statements here
21562 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21564 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
21565 if(!isWasmInitialized) {
21566 throw new Error("initializeWasm() must be awaited first!");
21568 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
21569 return nativeResponseValue;
21571 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21573 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
21574 if(!isWasmInitialized) {
21575 throw new Error("initializeWasm() must be awaited first!");
21577 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
21578 // debug statements here
21580 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21582 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
21583 if(!isWasmInitialized) {
21584 throw new Error("initializeWasm() must be awaited first!");
21586 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21587 return nativeResponseValue;
21589 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21591 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
21592 if(!isWasmInitialized) {
21593 throw new Error("initializeWasm() must be awaited first!");
21595 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21596 // debug statements here
21598 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21600 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
21601 if(!isWasmInitialized) {
21602 throw new Error("initializeWasm() must be awaited first!");
21604 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
21605 return nativeResponseValue;
21607 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21609 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
21610 if(!isWasmInitialized) {
21611 throw new Error("initializeWasm() must be awaited first!");
21613 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
21614 // debug statements here
21616 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21618 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
21619 if(!isWasmInitialized) {
21620 throw new Error("initializeWasm() must be awaited first!");
21622 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
21623 return nativeResponseValue;
21625 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21627 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
21628 if(!isWasmInitialized) {
21629 throw new Error("initializeWasm() must be awaited first!");
21631 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
21632 // debug statements here
21634 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21636 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
21637 if(!isWasmInitialized) {
21638 throw new Error("initializeWasm() must be awaited first!");
21640 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
21641 return nativeResponseValue;
21643 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
21645 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
21646 if(!isWasmInitialized) {
21647 throw new Error("initializeWasm() must be awaited first!");
21649 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
21650 // debug statements here
21652 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21654 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
21655 if(!isWasmInitialized) {
21656 throw new Error("initializeWasm() must be awaited first!");
21658 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
21659 return nativeResponseValue;
21661 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21663 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
21664 if(!isWasmInitialized) {
21665 throw new Error("initializeWasm() must be awaited first!");
21667 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
21668 // debug statements here
21670 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21672 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
21673 if(!isWasmInitialized) {
21674 throw new Error("initializeWasm() must be awaited first!");
21676 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
21677 return nativeResponseValue;
21679 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21681 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
21682 if(!isWasmInitialized) {
21683 throw new Error("initializeWasm() must be awaited first!");
21685 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
21686 // debug statements here
21688 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21690 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
21691 if(!isWasmInitialized) {
21692 throw new Error("initializeWasm() must be awaited first!");
21694 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
21695 return nativeResponseValue;
21697 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21699 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
21700 if(!isWasmInitialized) {
21701 throw new Error("initializeWasm() must be awaited first!");
21703 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
21704 // debug statements here
21706 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21708 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
21709 if(!isWasmInitialized) {
21710 throw new Error("initializeWasm() must be awaited first!");
21712 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
21713 return nativeResponseValue;
21715 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21717 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
21718 if(!isWasmInitialized) {
21719 throw new Error("initializeWasm() must be awaited first!");
21721 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
21722 // debug statements here
21724 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21726 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
21727 if(!isWasmInitialized) {
21728 throw new Error("initializeWasm() must be awaited first!");
21730 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
21731 return nativeResponseValue;
21733 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21735 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
21736 if(!isWasmInitialized) {
21737 throw new Error("initializeWasm() must be awaited first!");
21739 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
21740 // debug statements here
21742 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21744 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
21745 if(!isWasmInitialized) {
21746 throw new Error("initializeWasm() must be awaited first!");
21748 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
21749 return nativeResponseValue;
21751 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21753 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
21754 if(!isWasmInitialized) {
21755 throw new Error("initializeWasm() must be awaited first!");
21757 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
21758 // debug statements here
21760 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21762 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
21763 if(!isWasmInitialized) {
21764 throw new Error("initializeWasm() must be awaited first!");
21766 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
21767 return nativeResponseValue;
21769 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21771 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
21772 if(!isWasmInitialized) {
21773 throw new Error("initializeWasm() must be awaited first!");
21775 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
21776 // debug statements here
21778 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21780 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
21781 if(!isWasmInitialized) {
21782 throw new Error("initializeWasm() must be awaited first!");
21784 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
21785 return nativeResponseValue;
21787 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21789 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
21790 if(!isWasmInitialized) {
21791 throw new Error("initializeWasm() must be awaited first!");
21793 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21794 // debug statements here
21796 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21798 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
21799 if(!isWasmInitialized) {
21800 throw new Error("initializeWasm() must be awaited first!");
21802 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21803 return nativeResponseValue;
21805 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21807 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
21808 if(!isWasmInitialized) {
21809 throw new Error("initializeWasm() must be awaited first!");
21811 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21812 // debug statements here
21814 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21816 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
21817 if(!isWasmInitialized) {
21818 throw new Error("initializeWasm() must be awaited first!");
21820 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21821 return nativeResponseValue;
21823 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21825 export function AcceptChannel_clone(orig: bigint): bigint {
21826 if(!isWasmInitialized) {
21827 throw new Error("initializeWasm() must be awaited first!");
21829 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21830 return nativeResponseValue;
21832 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21834 export function FundingCreated_free(this_obj: bigint): void {
21835 if(!isWasmInitialized) {
21836 throw new Error("initializeWasm() must be awaited first!");
21838 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21839 // debug statements here
21841 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21843 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
21844 if(!isWasmInitialized) {
21845 throw new Error("initializeWasm() must be awaited first!");
21847 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21848 return nativeResponseValue;
21850 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21852 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
21853 if(!isWasmInitialized) {
21854 throw new Error("initializeWasm() must be awaited first!");
21856 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21857 // debug statements here
21859 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21861 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
21862 if(!isWasmInitialized) {
21863 throw new Error("initializeWasm() must be awaited first!");
21865 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21866 return nativeResponseValue;
21868 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21870 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
21871 if(!isWasmInitialized) {
21872 throw new Error("initializeWasm() must be awaited first!");
21874 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21875 // debug statements here
21877 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21879 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
21880 if(!isWasmInitialized) {
21881 throw new Error("initializeWasm() must be awaited first!");
21883 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21884 return nativeResponseValue;
21886 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21888 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
21889 if(!isWasmInitialized) {
21890 throw new Error("initializeWasm() must be awaited first!");
21892 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21893 // debug statements here
21895 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21897 export function FundingCreated_get_signature(this_ptr: bigint): number {
21898 if(!isWasmInitialized) {
21899 throw new Error("initializeWasm() must be awaited first!");
21901 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21902 return nativeResponseValue;
21904 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21906 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
21907 if(!isWasmInitialized) {
21908 throw new Error("initializeWasm() must be awaited first!");
21910 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21911 // debug statements here
21913 // MUST_USE_RES struct LDKFundingCreated FundingCreated_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, struct LDKThirtyTwoBytes funding_txid_arg, uint16_t funding_output_index_arg, struct LDKSignature signature_arg);
21915 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
21916 if(!isWasmInitialized) {
21917 throw new Error("initializeWasm() must be awaited first!");
21919 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21920 return nativeResponseValue;
21922 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21924 export function FundingCreated_clone_ptr(arg: bigint): bigint {
21925 if(!isWasmInitialized) {
21926 throw new Error("initializeWasm() must be awaited first!");
21928 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21929 return nativeResponseValue;
21931 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21933 export function FundingCreated_clone(orig: bigint): bigint {
21934 if(!isWasmInitialized) {
21935 throw new Error("initializeWasm() must be awaited first!");
21937 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21938 return nativeResponseValue;
21940 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21942 export function FundingSigned_free(this_obj: bigint): void {
21943 if(!isWasmInitialized) {
21944 throw new Error("initializeWasm() must be awaited first!");
21946 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21947 // debug statements here
21949 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21951 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
21952 if(!isWasmInitialized) {
21953 throw new Error("initializeWasm() must be awaited first!");
21955 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21956 return nativeResponseValue;
21958 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21960 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
21961 if(!isWasmInitialized) {
21962 throw new Error("initializeWasm() must be awaited first!");
21964 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21965 // debug statements here
21967 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21969 export function FundingSigned_get_signature(this_ptr: bigint): number {
21970 if(!isWasmInitialized) {
21971 throw new Error("initializeWasm() must be awaited first!");
21973 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21974 return nativeResponseValue;
21976 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21978 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
21979 if(!isWasmInitialized) {
21980 throw new Error("initializeWasm() must be awaited first!");
21982 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21983 // debug statements here
21985 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21987 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
21988 if(!isWasmInitialized) {
21989 throw new Error("initializeWasm() must be awaited first!");
21991 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21992 return nativeResponseValue;
21994 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21996 export function FundingSigned_clone_ptr(arg: bigint): bigint {
21997 if(!isWasmInitialized) {
21998 throw new Error("initializeWasm() must be awaited first!");
22000 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
22001 return nativeResponseValue;
22003 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
22005 export function FundingSigned_clone(orig: bigint): bigint {
22006 if(!isWasmInitialized) {
22007 throw new Error("initializeWasm() must be awaited first!");
22009 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
22010 return nativeResponseValue;
22012 // void ChannelReady_free(struct LDKChannelReady this_obj);
22014 export function ChannelReady_free(this_obj: bigint): void {
22015 if(!isWasmInitialized) {
22016 throw new Error("initializeWasm() must be awaited first!");
22018 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
22019 // debug statements here
22021 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
22023 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
22024 if(!isWasmInitialized) {
22025 throw new Error("initializeWasm() must be awaited first!");
22027 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
22028 return nativeResponseValue;
22030 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22032 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
22033 if(!isWasmInitialized) {
22034 throw new Error("initializeWasm() must be awaited first!");
22036 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
22037 // debug statements here
22039 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
22041 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
22042 if(!isWasmInitialized) {
22043 throw new Error("initializeWasm() must be awaited first!");
22045 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
22046 return nativeResponseValue;
22048 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22050 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
22051 if(!isWasmInitialized) {
22052 throw new Error("initializeWasm() must be awaited first!");
22054 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
22055 // debug statements here
22057 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
22059 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
22060 if(!isWasmInitialized) {
22061 throw new Error("initializeWasm() must be awaited first!");
22063 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
22064 return nativeResponseValue;
22066 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22068 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
22069 if(!isWasmInitialized) {
22070 throw new Error("initializeWasm() must be awaited first!");
22072 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
22073 // debug statements here
22075 // 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);
22077 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
22078 if(!isWasmInitialized) {
22079 throw new Error("initializeWasm() must be awaited first!");
22081 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
22082 return nativeResponseValue;
22084 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
22086 export function ChannelReady_clone_ptr(arg: bigint): bigint {
22087 if(!isWasmInitialized) {
22088 throw new Error("initializeWasm() must be awaited first!");
22090 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
22091 return nativeResponseValue;
22093 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
22095 export function ChannelReady_clone(orig: bigint): bigint {
22096 if(!isWasmInitialized) {
22097 throw new Error("initializeWasm() must be awaited first!");
22099 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
22100 return nativeResponseValue;
22102 // void Shutdown_free(struct LDKShutdown this_obj);
22104 export function Shutdown_free(this_obj: bigint): void {
22105 if(!isWasmInitialized) {
22106 throw new Error("initializeWasm() must be awaited first!");
22108 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
22109 // debug statements here
22111 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
22113 export function Shutdown_get_channel_id(this_ptr: bigint): number {
22114 if(!isWasmInitialized) {
22115 throw new Error("initializeWasm() must be awaited first!");
22117 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
22118 return nativeResponseValue;
22120 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22122 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
22123 if(!isWasmInitialized) {
22124 throw new Error("initializeWasm() must be awaited first!");
22126 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
22127 // debug statements here
22129 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
22131 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
22132 if(!isWasmInitialized) {
22133 throw new Error("initializeWasm() must be awaited first!");
22135 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
22136 return nativeResponseValue;
22138 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
22140 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
22141 if(!isWasmInitialized) {
22142 throw new Error("initializeWasm() must be awaited first!");
22144 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
22145 // debug statements here
22147 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
22149 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
22150 if(!isWasmInitialized) {
22151 throw new Error("initializeWasm() must be awaited first!");
22153 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
22154 return nativeResponseValue;
22156 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
22158 export function Shutdown_clone_ptr(arg: bigint): bigint {
22159 if(!isWasmInitialized) {
22160 throw new Error("initializeWasm() must be awaited first!");
22162 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
22163 return nativeResponseValue;
22165 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
22167 export function Shutdown_clone(orig: bigint): bigint {
22168 if(!isWasmInitialized) {
22169 throw new Error("initializeWasm() must be awaited first!");
22171 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
22172 return nativeResponseValue;
22174 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
22176 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
22177 if(!isWasmInitialized) {
22178 throw new Error("initializeWasm() must be awaited first!");
22180 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
22181 // debug statements here
22183 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
22185 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
22186 if(!isWasmInitialized) {
22187 throw new Error("initializeWasm() must be awaited first!");
22189 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
22190 return nativeResponseValue;
22192 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
22194 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
22195 if(!isWasmInitialized) {
22196 throw new Error("initializeWasm() must be awaited first!");
22198 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
22199 // debug statements here
22201 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
22203 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
22204 if(!isWasmInitialized) {
22205 throw new Error("initializeWasm() must be awaited first!");
22207 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
22208 return nativeResponseValue;
22210 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
22212 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
22213 if(!isWasmInitialized) {
22214 throw new Error("initializeWasm() must be awaited first!");
22216 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
22217 // debug statements here
22219 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
22221 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
22222 if(!isWasmInitialized) {
22223 throw new Error("initializeWasm() must be awaited first!");
22225 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
22226 return nativeResponseValue;
22228 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
22230 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
22231 if(!isWasmInitialized) {
22232 throw new Error("initializeWasm() must be awaited first!");
22234 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
22235 return nativeResponseValue;
22237 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
22239 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
22240 if(!isWasmInitialized) {
22241 throw new Error("initializeWasm() must be awaited first!");
22243 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
22244 return nativeResponseValue;
22246 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
22248 export function ClosingSigned_free(this_obj: bigint): void {
22249 if(!isWasmInitialized) {
22250 throw new Error("initializeWasm() must be awaited first!");
22252 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
22253 // debug statements here
22255 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
22257 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
22258 if(!isWasmInitialized) {
22259 throw new Error("initializeWasm() must be awaited first!");
22261 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
22262 return nativeResponseValue;
22264 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22266 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
22267 if(!isWasmInitialized) {
22268 throw new Error("initializeWasm() must be awaited first!");
22270 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
22271 // debug statements here
22273 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22275 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
22276 if(!isWasmInitialized) {
22277 throw new Error("initializeWasm() must be awaited first!");
22279 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
22280 return nativeResponseValue;
22282 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
22284 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
22285 if(!isWasmInitialized) {
22286 throw new Error("initializeWasm() must be awaited first!");
22288 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
22289 // debug statements here
22291 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22293 export function ClosingSigned_get_signature(this_ptr: bigint): number {
22294 if(!isWasmInitialized) {
22295 throw new Error("initializeWasm() must be awaited first!");
22297 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
22298 return nativeResponseValue;
22300 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22302 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
22303 if(!isWasmInitialized) {
22304 throw new Error("initializeWasm() must be awaited first!");
22306 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
22307 // debug statements here
22309 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22311 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
22312 if(!isWasmInitialized) {
22313 throw new Error("initializeWasm() must be awaited first!");
22315 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
22316 return nativeResponseValue;
22318 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
22320 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
22321 if(!isWasmInitialized) {
22322 throw new Error("initializeWasm() must be awaited first!");
22324 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
22325 // debug statements here
22327 // MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKSignature signature_arg, struct LDKClosingSignedFeeRange fee_range_arg);
22329 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
22330 if(!isWasmInitialized) {
22331 throw new Error("initializeWasm() must be awaited first!");
22333 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
22334 return nativeResponseValue;
22336 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
22338 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
22339 if(!isWasmInitialized) {
22340 throw new Error("initializeWasm() must be awaited first!");
22342 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
22343 return nativeResponseValue;
22345 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
22347 export function ClosingSigned_clone(orig: bigint): bigint {
22348 if(!isWasmInitialized) {
22349 throw new Error("initializeWasm() must be awaited first!");
22351 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
22352 return nativeResponseValue;
22354 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
22356 export function UpdateAddHTLC_free(this_obj: bigint): void {
22357 if(!isWasmInitialized) {
22358 throw new Error("initializeWasm() must be awaited first!");
22360 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
22361 // debug statements here
22363 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
22365 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
22366 if(!isWasmInitialized) {
22367 throw new Error("initializeWasm() must be awaited first!");
22369 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
22370 return nativeResponseValue;
22372 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22374 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
22375 if(!isWasmInitialized) {
22376 throw new Error("initializeWasm() must be awaited first!");
22378 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
22379 // debug statements here
22381 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22383 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
22384 if(!isWasmInitialized) {
22385 throw new Error("initializeWasm() must be awaited first!");
22387 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
22388 return nativeResponseValue;
22390 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
22392 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
22393 if(!isWasmInitialized) {
22394 throw new Error("initializeWasm() must be awaited first!");
22396 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
22397 // debug statements here
22399 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22401 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
22402 if(!isWasmInitialized) {
22403 throw new Error("initializeWasm() must be awaited first!");
22405 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
22406 return nativeResponseValue;
22408 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
22410 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
22411 if(!isWasmInitialized) {
22412 throw new Error("initializeWasm() must be awaited first!");
22414 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
22415 // debug statements here
22417 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
22419 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
22420 if(!isWasmInitialized) {
22421 throw new Error("initializeWasm() must be awaited first!");
22423 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
22424 return nativeResponseValue;
22426 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22428 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
22429 if(!isWasmInitialized) {
22430 throw new Error("initializeWasm() must be awaited first!");
22432 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
22433 // debug statements here
22435 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22437 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
22438 if(!isWasmInitialized) {
22439 throw new Error("initializeWasm() must be awaited first!");
22441 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
22442 return nativeResponseValue;
22444 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
22446 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
22447 if(!isWasmInitialized) {
22448 throw new Error("initializeWasm() must be awaited first!");
22450 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
22451 // debug statements here
22453 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
22455 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
22456 if(!isWasmInitialized) {
22457 throw new Error("initializeWasm() must be awaited first!");
22459 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
22460 return nativeResponseValue;
22462 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
22464 export function UpdateAddHTLC_clone(orig: bigint): bigint {
22465 if(!isWasmInitialized) {
22466 throw new Error("initializeWasm() must be awaited first!");
22468 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
22469 return nativeResponseValue;
22471 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
22473 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
22474 if(!isWasmInitialized) {
22475 throw new Error("initializeWasm() must be awaited first!");
22477 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
22478 // debug statements here
22480 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22482 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
22483 if(!isWasmInitialized) {
22484 throw new Error("initializeWasm() must be awaited first!");
22486 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
22487 return nativeResponseValue;
22489 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22491 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
22492 if(!isWasmInitialized) {
22493 throw new Error("initializeWasm() must be awaited first!");
22495 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
22496 // debug statements here
22498 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
22500 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
22501 if(!isWasmInitialized) {
22502 throw new Error("initializeWasm() must be awaited first!");
22504 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
22505 return nativeResponseValue;
22507 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
22509 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
22510 if(!isWasmInitialized) {
22511 throw new Error("initializeWasm() must be awaited first!");
22513 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
22514 // debug statements here
22516 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22518 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
22519 if(!isWasmInitialized) {
22520 throw new Error("initializeWasm() must be awaited first!");
22522 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
22523 return nativeResponseValue;
22525 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22527 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
22528 if(!isWasmInitialized) {
22529 throw new Error("initializeWasm() must be awaited first!");
22531 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
22532 // debug statements here
22534 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
22536 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
22537 if(!isWasmInitialized) {
22538 throw new Error("initializeWasm() must be awaited first!");
22540 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
22541 return nativeResponseValue;
22543 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
22545 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
22546 if(!isWasmInitialized) {
22547 throw new Error("initializeWasm() must be awaited first!");
22549 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
22550 return nativeResponseValue;
22552 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
22554 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
22555 if(!isWasmInitialized) {
22556 throw new Error("initializeWasm() must be awaited first!");
22558 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
22559 return nativeResponseValue;
22561 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
22563 export function UpdateFailHTLC_free(this_obj: bigint): void {
22564 if(!isWasmInitialized) {
22565 throw new Error("initializeWasm() must be awaited first!");
22567 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
22568 // debug statements here
22570 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
22572 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
22573 if(!isWasmInitialized) {
22574 throw new Error("initializeWasm() must be awaited first!");
22576 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
22577 return nativeResponseValue;
22579 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22581 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
22582 if(!isWasmInitialized) {
22583 throw new Error("initializeWasm() must be awaited first!");
22585 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
22586 // debug statements here
22588 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
22590 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
22591 if(!isWasmInitialized) {
22592 throw new Error("initializeWasm() must be awaited first!");
22594 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
22595 return nativeResponseValue;
22597 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
22599 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
22600 if(!isWasmInitialized) {
22601 throw new Error("initializeWasm() must be awaited first!");
22603 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
22604 // debug statements here
22606 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
22608 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
22609 if(!isWasmInitialized) {
22610 throw new Error("initializeWasm() must be awaited first!");
22612 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
22613 return nativeResponseValue;
22615 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
22617 export function UpdateFailHTLC_clone(orig: bigint): bigint {
22618 if(!isWasmInitialized) {
22619 throw new Error("initializeWasm() must be awaited first!");
22621 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
22622 return nativeResponseValue;
22624 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
22626 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
22627 if(!isWasmInitialized) {
22628 throw new Error("initializeWasm() must be awaited first!");
22630 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
22631 // debug statements here
22633 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
22635 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
22636 if(!isWasmInitialized) {
22637 throw new Error("initializeWasm() must be awaited first!");
22639 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
22640 return nativeResponseValue;
22642 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22644 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
22645 if(!isWasmInitialized) {
22646 throw new Error("initializeWasm() must be awaited first!");
22648 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
22649 // debug statements here
22651 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22653 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
22654 if(!isWasmInitialized) {
22655 throw new Error("initializeWasm() must be awaited first!");
22657 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
22658 return nativeResponseValue;
22660 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
22662 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
22663 if(!isWasmInitialized) {
22664 throw new Error("initializeWasm() must be awaited first!");
22666 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
22667 // debug statements here
22669 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22671 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
22672 if(!isWasmInitialized) {
22673 throw new Error("initializeWasm() must be awaited first!");
22675 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
22676 return nativeResponseValue;
22678 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
22680 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
22681 if(!isWasmInitialized) {
22682 throw new Error("initializeWasm() must be awaited first!");
22684 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
22685 // debug statements here
22687 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
22689 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
22690 if(!isWasmInitialized) {
22691 throw new Error("initializeWasm() must be awaited first!");
22693 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
22694 return nativeResponseValue;
22696 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
22698 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
22699 if(!isWasmInitialized) {
22700 throw new Error("initializeWasm() must be awaited first!");
22702 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
22703 return nativeResponseValue;
22705 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
22707 export function CommitmentSigned_free(this_obj: bigint): void {
22708 if(!isWasmInitialized) {
22709 throw new Error("initializeWasm() must be awaited first!");
22711 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
22712 // debug statements here
22714 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
22716 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
22717 if(!isWasmInitialized) {
22718 throw new Error("initializeWasm() must be awaited first!");
22720 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
22721 return nativeResponseValue;
22723 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22725 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
22726 if(!isWasmInitialized) {
22727 throw new Error("initializeWasm() must be awaited first!");
22729 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
22730 // debug statements here
22732 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22734 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
22735 if(!isWasmInitialized) {
22736 throw new Error("initializeWasm() must be awaited first!");
22738 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
22739 return nativeResponseValue;
22741 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22743 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
22744 if(!isWasmInitialized) {
22745 throw new Error("initializeWasm() must be awaited first!");
22747 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
22748 // debug statements here
22750 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22752 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
22753 if(!isWasmInitialized) {
22754 throw new Error("initializeWasm() must be awaited first!");
22756 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
22757 return nativeResponseValue;
22759 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22761 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
22762 if(!isWasmInitialized) {
22763 throw new Error("initializeWasm() must be awaited first!");
22765 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
22766 // debug statements here
22768 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
22770 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
22771 if(!isWasmInitialized) {
22772 throw new Error("initializeWasm() must be awaited first!");
22774 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
22775 return nativeResponseValue;
22777 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
22779 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
22780 if(!isWasmInitialized) {
22781 throw new Error("initializeWasm() must be awaited first!");
22783 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
22784 return nativeResponseValue;
22786 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
22788 export function CommitmentSigned_clone(orig: bigint): bigint {
22789 if(!isWasmInitialized) {
22790 throw new Error("initializeWasm() must be awaited first!");
22792 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
22793 return nativeResponseValue;
22795 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
22797 export function RevokeAndACK_free(this_obj: bigint): void {
22798 if(!isWasmInitialized) {
22799 throw new Error("initializeWasm() must be awaited first!");
22801 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22802 // debug statements here
22804 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22806 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
22807 if(!isWasmInitialized) {
22808 throw new Error("initializeWasm() must be awaited first!");
22810 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22811 return nativeResponseValue;
22813 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22815 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
22816 if(!isWasmInitialized) {
22817 throw new Error("initializeWasm() must be awaited first!");
22819 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22820 // debug statements here
22822 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22824 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
22825 if(!isWasmInitialized) {
22826 throw new Error("initializeWasm() must be awaited first!");
22828 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22829 return nativeResponseValue;
22831 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22833 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
22834 if(!isWasmInitialized) {
22835 throw new Error("initializeWasm() must be awaited first!");
22837 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22838 // debug statements here
22840 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22842 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
22843 if(!isWasmInitialized) {
22844 throw new Error("initializeWasm() must be awaited first!");
22846 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22847 return nativeResponseValue;
22849 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22851 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
22852 if(!isWasmInitialized) {
22853 throw new Error("initializeWasm() must be awaited first!");
22855 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22856 // debug statements here
22858 // 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);
22860 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
22861 if(!isWasmInitialized) {
22862 throw new Error("initializeWasm() must be awaited first!");
22864 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22865 return nativeResponseValue;
22867 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22869 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
22870 if(!isWasmInitialized) {
22871 throw new Error("initializeWasm() must be awaited first!");
22873 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22874 return nativeResponseValue;
22876 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22878 export function RevokeAndACK_clone(orig: bigint): bigint {
22879 if(!isWasmInitialized) {
22880 throw new Error("initializeWasm() must be awaited first!");
22882 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22883 return nativeResponseValue;
22885 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22887 export function UpdateFee_free(this_obj: bigint): void {
22888 if(!isWasmInitialized) {
22889 throw new Error("initializeWasm() must be awaited first!");
22891 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22892 // debug statements here
22894 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22896 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
22897 if(!isWasmInitialized) {
22898 throw new Error("initializeWasm() must be awaited first!");
22900 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22901 return nativeResponseValue;
22903 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22905 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
22906 if(!isWasmInitialized) {
22907 throw new Error("initializeWasm() must be awaited first!");
22909 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22910 // debug statements here
22912 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22914 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
22915 if(!isWasmInitialized) {
22916 throw new Error("initializeWasm() must be awaited first!");
22918 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22919 return nativeResponseValue;
22921 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22923 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
22924 if(!isWasmInitialized) {
22925 throw new Error("initializeWasm() must be awaited first!");
22927 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22928 // debug statements here
22930 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22932 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
22933 if(!isWasmInitialized) {
22934 throw new Error("initializeWasm() must be awaited first!");
22936 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22937 return nativeResponseValue;
22939 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22941 export function UpdateFee_clone_ptr(arg: bigint): bigint {
22942 if(!isWasmInitialized) {
22943 throw new Error("initializeWasm() must be awaited first!");
22945 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22946 return nativeResponseValue;
22948 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22950 export function UpdateFee_clone(orig: bigint): bigint {
22951 if(!isWasmInitialized) {
22952 throw new Error("initializeWasm() must be awaited first!");
22954 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22955 return nativeResponseValue;
22957 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22959 export function DataLossProtect_free(this_obj: bigint): void {
22960 if(!isWasmInitialized) {
22961 throw new Error("initializeWasm() must be awaited first!");
22963 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22964 // debug statements here
22966 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22968 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: bigint): number {
22969 if(!isWasmInitialized) {
22970 throw new Error("initializeWasm() must be awaited first!");
22972 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22973 return nativeResponseValue;
22975 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22977 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
22978 if(!isWasmInitialized) {
22979 throw new Error("initializeWasm() must be awaited first!");
22981 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22982 // debug statements here
22984 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22986 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: bigint): number {
22987 if(!isWasmInitialized) {
22988 throw new Error("initializeWasm() must be awaited first!");
22990 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22991 return nativeResponseValue;
22993 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22995 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
22996 if(!isWasmInitialized) {
22997 throw new Error("initializeWasm() must be awaited first!");
22999 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
23000 // debug statements here
23002 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
23004 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): bigint {
23005 if(!isWasmInitialized) {
23006 throw new Error("initializeWasm() must be awaited first!");
23008 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
23009 return nativeResponseValue;
23011 // uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
23013 export function DataLossProtect_clone_ptr(arg: bigint): bigint {
23014 if(!isWasmInitialized) {
23015 throw new Error("initializeWasm() must be awaited first!");
23017 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
23018 return nativeResponseValue;
23020 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
23022 export function DataLossProtect_clone(orig: bigint): bigint {
23023 if(!isWasmInitialized) {
23024 throw new Error("initializeWasm() must be awaited first!");
23026 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
23027 return nativeResponseValue;
23029 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
23031 export function ChannelReestablish_free(this_obj: bigint): void {
23032 if(!isWasmInitialized) {
23033 throw new Error("initializeWasm() must be awaited first!");
23035 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
23036 // debug statements here
23038 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
23040 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
23041 if(!isWasmInitialized) {
23042 throw new Error("initializeWasm() must be awaited first!");
23044 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
23045 return nativeResponseValue;
23047 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23049 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
23050 if(!isWasmInitialized) {
23051 throw new Error("initializeWasm() must be awaited first!");
23053 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
23054 // debug statements here
23056 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
23058 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
23059 if(!isWasmInitialized) {
23060 throw new Error("initializeWasm() must be awaited first!");
23062 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
23063 return nativeResponseValue;
23065 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
23067 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
23068 if(!isWasmInitialized) {
23069 throw new Error("initializeWasm() must be awaited first!");
23071 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
23072 // debug statements here
23074 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
23076 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
23077 if(!isWasmInitialized) {
23078 throw new Error("initializeWasm() must be awaited first!");
23080 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
23081 return nativeResponseValue;
23083 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
23085 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
23086 if(!isWasmInitialized) {
23087 throw new Error("initializeWasm() must be awaited first!");
23089 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
23090 // debug statements here
23092 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
23094 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
23095 if(!isWasmInitialized) {
23096 throw new Error("initializeWasm() must be awaited first!");
23098 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
23099 return nativeResponseValue;
23101 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
23103 export function ChannelReestablish_clone(orig: bigint): bigint {
23104 if(!isWasmInitialized) {
23105 throw new Error("initializeWasm() must be awaited first!");
23107 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
23108 return nativeResponseValue;
23110 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
23112 export function AnnouncementSignatures_free(this_obj: bigint): void {
23113 if(!isWasmInitialized) {
23114 throw new Error("initializeWasm() must be awaited first!");
23116 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
23117 // debug statements here
23119 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
23121 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
23122 if(!isWasmInitialized) {
23123 throw new Error("initializeWasm() must be awaited first!");
23125 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
23126 return nativeResponseValue;
23128 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23130 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
23131 if(!isWasmInitialized) {
23132 throw new Error("initializeWasm() must be awaited first!");
23134 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
23135 // debug statements here
23137 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23139 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
23140 if(!isWasmInitialized) {
23141 throw new Error("initializeWasm() must be awaited first!");
23143 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
23144 return nativeResponseValue;
23146 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
23148 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
23149 if(!isWasmInitialized) {
23150 throw new Error("initializeWasm() must be awaited first!");
23152 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
23153 // debug statements here
23155 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23157 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
23158 if(!isWasmInitialized) {
23159 throw new Error("initializeWasm() must be awaited first!");
23161 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
23162 return nativeResponseValue;
23164 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
23166 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
23167 if(!isWasmInitialized) {
23168 throw new Error("initializeWasm() must be awaited first!");
23170 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
23171 // debug statements here
23173 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23175 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
23176 if(!isWasmInitialized) {
23177 throw new Error("initializeWasm() must be awaited first!");
23179 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
23180 return nativeResponseValue;
23182 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
23184 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
23185 if(!isWasmInitialized) {
23186 throw new Error("initializeWasm() must be awaited first!");
23188 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
23189 // debug statements here
23191 // MUST_USE_RES struct LDKAnnouncementSignatures AnnouncementSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t short_channel_id_arg, struct LDKSignature node_signature_arg, struct LDKSignature bitcoin_signature_arg);
23193 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
23194 if(!isWasmInitialized) {
23195 throw new Error("initializeWasm() must be awaited first!");
23197 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
23198 return nativeResponseValue;
23200 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
23202 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
23203 if(!isWasmInitialized) {
23204 throw new Error("initializeWasm() must be awaited first!");
23206 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
23207 return nativeResponseValue;
23209 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
23211 export function AnnouncementSignatures_clone(orig: bigint): bigint {
23212 if(!isWasmInitialized) {
23213 throw new Error("initializeWasm() must be awaited first!");
23215 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
23216 return nativeResponseValue;
23218 // void NetAddress_free(struct LDKNetAddress this_ptr);
23220 export function NetAddress_free(this_ptr: bigint): void {
23221 if(!isWasmInitialized) {
23222 throw new Error("initializeWasm() must be awaited first!");
23224 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
23225 // debug statements here
23227 // uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
23229 export function NetAddress_clone_ptr(arg: bigint): bigint {
23230 if(!isWasmInitialized) {
23231 throw new Error("initializeWasm() must be awaited first!");
23233 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
23234 return nativeResponseValue;
23236 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
23238 export function NetAddress_clone(orig: bigint): bigint {
23239 if(!isWasmInitialized) {
23240 throw new Error("initializeWasm() must be awaited first!");
23242 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
23243 return nativeResponseValue;
23245 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
23247 export function NetAddress_ipv4(addr: number, port: number): bigint {
23248 if(!isWasmInitialized) {
23249 throw new Error("initializeWasm() must be awaited first!");
23251 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
23252 return nativeResponseValue;
23254 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
23256 export function NetAddress_ipv6(addr: number, port: number): bigint {
23257 if(!isWasmInitialized) {
23258 throw new Error("initializeWasm() must be awaited first!");
23260 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
23261 return nativeResponseValue;
23263 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
23265 export function NetAddress_onion_v2(a: number): bigint {
23266 if(!isWasmInitialized) {
23267 throw new Error("initializeWasm() must be awaited first!");
23269 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
23270 return nativeResponseValue;
23272 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
23274 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
23275 if(!isWasmInitialized) {
23276 throw new Error("initializeWasm() must be awaited first!");
23278 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
23279 return nativeResponseValue;
23281 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
23283 export function NetAddress_hostname(hostname: bigint, port: number): bigint {
23284 if(!isWasmInitialized) {
23285 throw new Error("initializeWasm() must be awaited first!");
23287 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
23288 return nativeResponseValue;
23290 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
23292 export function NetAddress_write(obj: bigint): number {
23293 if(!isWasmInitialized) {
23294 throw new Error("initializeWasm() must be awaited first!");
23296 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
23297 return nativeResponseValue;
23299 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
23301 export function NetAddress_read(ser: number): bigint {
23302 if(!isWasmInitialized) {
23303 throw new Error("initializeWasm() must be awaited first!");
23305 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
23306 return nativeResponseValue;
23308 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
23310 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
23311 if(!isWasmInitialized) {
23312 throw new Error("initializeWasm() must be awaited first!");
23314 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
23315 // debug statements here
23317 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23319 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
23320 if(!isWasmInitialized) {
23321 throw new Error("initializeWasm() must be awaited first!");
23323 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
23324 return nativeResponseValue;
23326 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
23328 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
23329 if(!isWasmInitialized) {
23330 throw new Error("initializeWasm() must be awaited first!");
23332 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
23333 // debug statements here
23335 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23337 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
23338 if(!isWasmInitialized) {
23339 throw new Error("initializeWasm() must be awaited first!");
23341 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
23342 return nativeResponseValue;
23344 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
23346 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
23347 if(!isWasmInitialized) {
23348 throw new Error("initializeWasm() must be awaited first!");
23350 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
23351 // debug statements here
23353 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23355 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): number {
23356 if(!isWasmInitialized) {
23357 throw new Error("initializeWasm() must be awaited first!");
23359 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
23360 return nativeResponseValue;
23362 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23364 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: number): void {
23365 if(!isWasmInitialized) {
23366 throw new Error("initializeWasm() must be awaited first!");
23368 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
23369 // debug statements here
23371 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
23373 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
23374 if(!isWasmInitialized) {
23375 throw new Error("initializeWasm() must be awaited first!");
23377 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
23378 return nativeResponseValue;
23380 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
23382 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
23383 if(!isWasmInitialized) {
23384 throw new Error("initializeWasm() must be awaited first!");
23386 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
23387 // debug statements here
23389 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
23391 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): number {
23392 if(!isWasmInitialized) {
23393 throw new Error("initializeWasm() must be awaited first!");
23395 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
23396 return nativeResponseValue;
23398 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23400 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: number): void {
23401 if(!isWasmInitialized) {
23402 throw new Error("initializeWasm() must be awaited first!");
23404 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
23405 // debug statements here
23407 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23409 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
23410 if(!isWasmInitialized) {
23411 throw new Error("initializeWasm() must be awaited first!");
23413 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
23414 return nativeResponseValue;
23416 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
23418 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
23419 if(!isWasmInitialized) {
23420 throw new Error("initializeWasm() must be awaited first!");
23422 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
23423 // debug statements here
23425 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
23427 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
23428 if(!isWasmInitialized) {
23429 throw new Error("initializeWasm() must be awaited first!");
23431 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
23432 return nativeResponseValue;
23434 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
23436 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
23437 if(!isWasmInitialized) {
23438 throw new Error("initializeWasm() must be awaited first!");
23440 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
23441 return nativeResponseValue;
23443 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
23445 export function NodeAnnouncement_free(this_obj: bigint): void {
23446 if(!isWasmInitialized) {
23447 throw new Error("initializeWasm() must be awaited first!");
23449 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
23450 // debug statements here
23452 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
23454 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
23455 if(!isWasmInitialized) {
23456 throw new Error("initializeWasm() must be awaited first!");
23458 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
23459 return nativeResponseValue;
23461 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23463 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
23464 if(!isWasmInitialized) {
23465 throw new Error("initializeWasm() must be awaited first!");
23467 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
23468 // debug statements here
23470 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
23472 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
23473 if(!isWasmInitialized) {
23474 throw new Error("initializeWasm() must be awaited first!");
23476 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
23477 return nativeResponseValue;
23479 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
23481 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
23482 if(!isWasmInitialized) {
23483 throw new Error("initializeWasm() must be awaited first!");
23485 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
23486 // debug statements here
23488 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
23490 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
23491 if(!isWasmInitialized) {
23492 throw new Error("initializeWasm() must be awaited first!");
23494 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
23495 return nativeResponseValue;
23497 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
23499 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
23500 if(!isWasmInitialized) {
23501 throw new Error("initializeWasm() must be awaited first!");
23503 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
23504 return nativeResponseValue;
23506 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
23508 export function NodeAnnouncement_clone(orig: bigint): bigint {
23509 if(!isWasmInitialized) {
23510 throw new Error("initializeWasm() must be awaited first!");
23512 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
23513 return nativeResponseValue;
23515 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
23517 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
23518 if(!isWasmInitialized) {
23519 throw new Error("initializeWasm() must be awaited first!");
23521 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
23522 // debug statements here
23524 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23526 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
23527 if(!isWasmInitialized) {
23528 throw new Error("initializeWasm() must be awaited first!");
23530 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
23531 return nativeResponseValue;
23533 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
23535 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
23536 if(!isWasmInitialized) {
23537 throw new Error("initializeWasm() must be awaited first!");
23539 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
23540 // debug statements here
23542 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
23544 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
23545 if(!isWasmInitialized) {
23546 throw new Error("initializeWasm() must be awaited first!");
23548 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
23549 return nativeResponseValue;
23551 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23553 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
23554 if(!isWasmInitialized) {
23555 throw new Error("initializeWasm() must be awaited first!");
23557 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
23558 // debug statements here
23560 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23562 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
23563 if(!isWasmInitialized) {
23564 throw new Error("initializeWasm() must be awaited first!");
23566 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
23567 return nativeResponseValue;
23569 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
23571 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
23572 if(!isWasmInitialized) {
23573 throw new Error("initializeWasm() must be awaited first!");
23575 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
23576 // debug statements here
23578 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23580 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): number {
23581 if(!isWasmInitialized) {
23582 throw new Error("initializeWasm() must be awaited first!");
23584 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
23585 return nativeResponseValue;
23587 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23589 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: number): void {
23590 if(!isWasmInitialized) {
23591 throw new Error("initializeWasm() must be awaited first!");
23593 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
23594 // debug statements here
23596 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23598 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): number {
23599 if(!isWasmInitialized) {
23600 throw new Error("initializeWasm() must be awaited first!");
23602 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
23603 return nativeResponseValue;
23605 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23607 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: number): void {
23608 if(!isWasmInitialized) {
23609 throw new Error("initializeWasm() must be awaited first!");
23611 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
23612 // debug statements here
23614 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23616 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): number {
23617 if(!isWasmInitialized) {
23618 throw new Error("initializeWasm() must be awaited first!");
23620 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
23621 return nativeResponseValue;
23623 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23625 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: number): void {
23626 if(!isWasmInitialized) {
23627 throw new Error("initializeWasm() must be awaited first!");
23629 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
23630 // debug statements here
23632 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23634 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): number {
23635 if(!isWasmInitialized) {
23636 throw new Error("initializeWasm() must be awaited first!");
23638 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
23639 return nativeResponseValue;
23641 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23643 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: number): void {
23644 if(!isWasmInitialized) {
23645 throw new Error("initializeWasm() must be awaited first!");
23647 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
23648 // debug statements here
23650 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
23652 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
23653 if(!isWasmInitialized) {
23654 throw new Error("initializeWasm() must be awaited first!");
23656 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
23657 return nativeResponseValue;
23659 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
23661 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
23662 if(!isWasmInitialized) {
23663 throw new Error("initializeWasm() must be awaited first!");
23665 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
23666 return nativeResponseValue;
23668 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
23670 export function ChannelAnnouncement_free(this_obj: bigint): void {
23671 if(!isWasmInitialized) {
23672 throw new Error("initializeWasm() must be awaited first!");
23674 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
23675 // debug statements here
23677 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23679 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
23680 if(!isWasmInitialized) {
23681 throw new Error("initializeWasm() must be awaited first!");
23683 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
23684 return nativeResponseValue;
23686 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23688 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
23689 if(!isWasmInitialized) {
23690 throw new Error("initializeWasm() must be awaited first!");
23692 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
23693 // debug statements here
23695 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23697 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
23698 if(!isWasmInitialized) {
23699 throw new Error("initializeWasm() must be awaited first!");
23701 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
23702 return nativeResponseValue;
23704 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23706 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
23707 if(!isWasmInitialized) {
23708 throw new Error("initializeWasm() must be awaited first!");
23710 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
23711 // debug statements here
23713 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23715 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
23716 if(!isWasmInitialized) {
23717 throw new Error("initializeWasm() must be awaited first!");
23719 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
23720 return nativeResponseValue;
23722 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23724 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
23725 if(!isWasmInitialized) {
23726 throw new Error("initializeWasm() must be awaited first!");
23728 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
23729 // debug statements here
23731 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23733 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
23734 if(!isWasmInitialized) {
23735 throw new Error("initializeWasm() must be awaited first!");
23737 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
23738 return nativeResponseValue;
23740 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23742 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
23743 if(!isWasmInitialized) {
23744 throw new Error("initializeWasm() must be awaited first!");
23746 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
23747 // debug statements here
23749 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23751 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
23752 if(!isWasmInitialized) {
23753 throw new Error("initializeWasm() must be awaited first!");
23755 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
23756 return nativeResponseValue;
23758 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
23760 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
23761 if(!isWasmInitialized) {
23762 throw new Error("initializeWasm() must be awaited first!");
23764 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
23765 // debug statements here
23767 // MUST_USE_RES struct LDKChannelAnnouncement ChannelAnnouncement_new(struct LDKSignature node_signature_1_arg, struct LDKSignature node_signature_2_arg, struct LDKSignature bitcoin_signature_1_arg, struct LDKSignature bitcoin_signature_2_arg, struct LDKUnsignedChannelAnnouncement contents_arg);
23769 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 {
23770 if(!isWasmInitialized) {
23771 throw new Error("initializeWasm() must be awaited first!");
23773 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
23774 return nativeResponseValue;
23776 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
23778 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
23779 if(!isWasmInitialized) {
23780 throw new Error("initializeWasm() must be awaited first!");
23782 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
23783 return nativeResponseValue;
23785 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
23787 export function ChannelAnnouncement_clone(orig: bigint): bigint {
23788 if(!isWasmInitialized) {
23789 throw new Error("initializeWasm() must be awaited first!");
23791 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
23792 return nativeResponseValue;
23794 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
23796 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
23797 if(!isWasmInitialized) {
23798 throw new Error("initializeWasm() must be awaited first!");
23800 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
23801 // debug statements here
23803 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
23805 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
23806 if(!isWasmInitialized) {
23807 throw new Error("initializeWasm() must be awaited first!");
23809 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
23810 return nativeResponseValue;
23812 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23814 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
23815 if(!isWasmInitialized) {
23816 throw new Error("initializeWasm() must be awaited first!");
23818 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23819 // debug statements here
23821 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23823 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
23824 if(!isWasmInitialized) {
23825 throw new Error("initializeWasm() must be awaited first!");
23827 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23828 return nativeResponseValue;
23830 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23832 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
23833 if(!isWasmInitialized) {
23834 throw new Error("initializeWasm() must be awaited first!");
23836 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23837 // debug statements here
23839 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23841 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
23842 if(!isWasmInitialized) {
23843 throw new Error("initializeWasm() must be awaited first!");
23845 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23846 return nativeResponseValue;
23848 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23850 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
23851 if(!isWasmInitialized) {
23852 throw new Error("initializeWasm() must be awaited first!");
23854 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23855 // debug statements here
23857 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23859 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
23860 if(!isWasmInitialized) {
23861 throw new Error("initializeWasm() must be awaited first!");
23863 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23864 return nativeResponseValue;
23866 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23868 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
23869 if(!isWasmInitialized) {
23870 throw new Error("initializeWasm() must be awaited first!");
23872 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23873 // debug statements here
23875 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23877 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
23878 if(!isWasmInitialized) {
23879 throw new Error("initializeWasm() must be awaited first!");
23881 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23882 return nativeResponseValue;
23884 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23886 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
23887 if(!isWasmInitialized) {
23888 throw new Error("initializeWasm() must be awaited first!");
23890 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23891 // debug statements here
23893 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23895 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
23896 if(!isWasmInitialized) {
23897 throw new Error("initializeWasm() must be awaited first!");
23899 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23900 return nativeResponseValue;
23902 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23904 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
23905 if(!isWasmInitialized) {
23906 throw new Error("initializeWasm() must be awaited first!");
23908 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23909 // debug statements here
23911 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23913 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
23914 if(!isWasmInitialized) {
23915 throw new Error("initializeWasm() must be awaited first!");
23917 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
23918 return nativeResponseValue;
23920 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23922 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
23923 if(!isWasmInitialized) {
23924 throw new Error("initializeWasm() must be awaited first!");
23926 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
23927 // debug statements here
23929 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23931 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
23932 if(!isWasmInitialized) {
23933 throw new Error("initializeWasm() must be awaited first!");
23935 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23936 return nativeResponseValue;
23938 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23940 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
23941 if(!isWasmInitialized) {
23942 throw new Error("initializeWasm() must be awaited first!");
23944 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23945 // debug statements here
23947 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23949 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
23950 if(!isWasmInitialized) {
23951 throw new Error("initializeWasm() must be awaited first!");
23953 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23954 return nativeResponseValue;
23956 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23958 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
23959 if(!isWasmInitialized) {
23960 throw new Error("initializeWasm() must be awaited first!");
23962 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23963 // debug statements here
23965 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23967 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
23968 if(!isWasmInitialized) {
23969 throw new Error("initializeWasm() must be awaited first!");
23971 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
23972 return nativeResponseValue;
23974 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23976 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
23977 if(!isWasmInitialized) {
23978 throw new Error("initializeWasm() must be awaited first!");
23980 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23981 // debug statements here
23983 // 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);
23985 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 {
23986 if(!isWasmInitialized) {
23987 throw new Error("initializeWasm() must be awaited first!");
23989 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);
23990 return nativeResponseValue;
23992 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23994 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
23995 if(!isWasmInitialized) {
23996 throw new Error("initializeWasm() must be awaited first!");
23998 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23999 return nativeResponseValue;
24001 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
24003 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
24004 if(!isWasmInitialized) {
24005 throw new Error("initializeWasm() must be awaited first!");
24007 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
24008 return nativeResponseValue;
24010 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
24012 export function ChannelUpdate_free(this_obj: bigint): void {
24013 if(!isWasmInitialized) {
24014 throw new Error("initializeWasm() must be awaited first!");
24016 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
24017 // debug statements here
24019 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
24021 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
24022 if(!isWasmInitialized) {
24023 throw new Error("initializeWasm() must be awaited first!");
24025 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
24026 return nativeResponseValue;
24028 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
24030 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
24031 if(!isWasmInitialized) {
24032 throw new Error("initializeWasm() must be awaited first!");
24034 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
24035 // debug statements here
24037 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
24039 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
24040 if(!isWasmInitialized) {
24041 throw new Error("initializeWasm() must be awaited first!");
24043 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
24044 return nativeResponseValue;
24046 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
24048 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
24049 if(!isWasmInitialized) {
24050 throw new Error("initializeWasm() must be awaited first!");
24052 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
24053 // debug statements here
24055 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
24057 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
24058 if(!isWasmInitialized) {
24059 throw new Error("initializeWasm() must be awaited first!");
24061 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
24062 return nativeResponseValue;
24064 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
24066 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
24067 if(!isWasmInitialized) {
24068 throw new Error("initializeWasm() must be awaited first!");
24070 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
24071 return nativeResponseValue;
24073 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
24075 export function ChannelUpdate_clone(orig: bigint): bigint {
24076 if(!isWasmInitialized) {
24077 throw new Error("initializeWasm() must be awaited first!");
24079 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
24080 return nativeResponseValue;
24082 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
24084 export function QueryChannelRange_free(this_obj: bigint): void {
24085 if(!isWasmInitialized) {
24086 throw new Error("initializeWasm() must be awaited first!");
24088 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
24089 // debug statements here
24091 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
24093 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
24094 if(!isWasmInitialized) {
24095 throw new Error("initializeWasm() must be awaited first!");
24097 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
24098 return nativeResponseValue;
24100 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24102 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
24103 if(!isWasmInitialized) {
24104 throw new Error("initializeWasm() must be awaited first!");
24106 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
24107 // debug statements here
24109 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
24111 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
24112 if(!isWasmInitialized) {
24113 throw new Error("initializeWasm() must be awaited first!");
24115 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
24116 return nativeResponseValue;
24118 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24120 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
24121 if(!isWasmInitialized) {
24122 throw new Error("initializeWasm() must be awaited first!");
24124 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
24125 // debug statements here
24127 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
24129 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
24130 if(!isWasmInitialized) {
24131 throw new Error("initializeWasm() must be awaited first!");
24133 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
24134 return nativeResponseValue;
24136 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24138 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
24139 if(!isWasmInitialized) {
24140 throw new Error("initializeWasm() must be awaited first!");
24142 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
24143 // debug statements here
24145 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
24147 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
24148 if(!isWasmInitialized) {
24149 throw new Error("initializeWasm() must be awaited first!");
24151 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
24152 return nativeResponseValue;
24154 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
24156 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
24157 if(!isWasmInitialized) {
24158 throw new Error("initializeWasm() must be awaited first!");
24160 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
24161 return nativeResponseValue;
24163 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
24165 export function QueryChannelRange_clone(orig: bigint): bigint {
24166 if(!isWasmInitialized) {
24167 throw new Error("initializeWasm() must be awaited first!");
24169 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
24170 return nativeResponseValue;
24172 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
24174 export function ReplyChannelRange_free(this_obj: bigint): void {
24175 if(!isWasmInitialized) {
24176 throw new Error("initializeWasm() must be awaited first!");
24178 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
24179 // debug statements here
24181 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
24183 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
24184 if(!isWasmInitialized) {
24185 throw new Error("initializeWasm() must be awaited first!");
24187 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
24188 return nativeResponseValue;
24190 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24192 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
24193 if(!isWasmInitialized) {
24194 throw new Error("initializeWasm() must be awaited first!");
24196 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
24197 // debug statements here
24199 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24201 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
24202 if(!isWasmInitialized) {
24203 throw new Error("initializeWasm() must be awaited first!");
24205 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
24206 return nativeResponseValue;
24208 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24210 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
24211 if(!isWasmInitialized) {
24212 throw new Error("initializeWasm() must be awaited first!");
24214 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
24215 // debug statements here
24217 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24219 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
24220 if(!isWasmInitialized) {
24221 throw new Error("initializeWasm() must be awaited first!");
24223 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
24224 return nativeResponseValue;
24226 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24228 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
24229 if(!isWasmInitialized) {
24230 throw new Error("initializeWasm() must be awaited first!");
24232 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
24233 // debug statements here
24235 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24237 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
24238 if(!isWasmInitialized) {
24239 throw new Error("initializeWasm() must be awaited first!");
24241 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
24242 return nativeResponseValue;
24244 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
24246 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
24247 if(!isWasmInitialized) {
24248 throw new Error("initializeWasm() must be awaited first!");
24250 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
24251 // debug statements here
24253 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24255 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
24256 if(!isWasmInitialized) {
24257 throw new Error("initializeWasm() must be awaited first!");
24259 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
24260 return nativeResponseValue;
24262 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24264 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
24265 if(!isWasmInitialized) {
24266 throw new Error("initializeWasm() must be awaited first!");
24268 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
24269 // debug statements here
24271 // 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);
24273 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 {
24274 if(!isWasmInitialized) {
24275 throw new Error("initializeWasm() must be awaited first!");
24277 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
24278 return nativeResponseValue;
24280 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
24282 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
24283 if(!isWasmInitialized) {
24284 throw new Error("initializeWasm() must be awaited first!");
24286 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
24287 return nativeResponseValue;
24289 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
24291 export function ReplyChannelRange_clone(orig: bigint): bigint {
24292 if(!isWasmInitialized) {
24293 throw new Error("initializeWasm() must be awaited first!");
24295 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
24296 return nativeResponseValue;
24298 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
24300 export function QueryShortChannelIds_free(this_obj: bigint): void {
24301 if(!isWasmInitialized) {
24302 throw new Error("initializeWasm() must be awaited first!");
24304 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
24305 // debug statements here
24307 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
24309 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
24310 if(!isWasmInitialized) {
24311 throw new Error("initializeWasm() must be awaited first!");
24313 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
24314 return nativeResponseValue;
24316 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24318 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
24319 if(!isWasmInitialized) {
24320 throw new Error("initializeWasm() must be awaited first!");
24322 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
24323 // debug statements here
24325 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
24327 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
24328 if(!isWasmInitialized) {
24329 throw new Error("initializeWasm() must be awaited first!");
24331 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
24332 return nativeResponseValue;
24334 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24336 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
24337 if(!isWasmInitialized) {
24338 throw new Error("initializeWasm() must be awaited first!");
24340 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
24341 // debug statements here
24343 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
24345 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
24346 if(!isWasmInitialized) {
24347 throw new Error("initializeWasm() must be awaited first!");
24349 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
24350 return nativeResponseValue;
24352 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
24354 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
24355 if(!isWasmInitialized) {
24356 throw new Error("initializeWasm() must be awaited first!");
24358 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
24359 return nativeResponseValue;
24361 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
24363 export function QueryShortChannelIds_clone(orig: bigint): bigint {
24364 if(!isWasmInitialized) {
24365 throw new Error("initializeWasm() must be awaited first!");
24367 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
24368 return nativeResponseValue;
24370 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
24372 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
24373 if(!isWasmInitialized) {
24374 throw new Error("initializeWasm() must be awaited first!");
24376 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
24377 // debug statements here
24379 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
24381 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
24382 if(!isWasmInitialized) {
24383 throw new Error("initializeWasm() must be awaited first!");
24385 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
24386 return nativeResponseValue;
24388 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24390 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
24391 if(!isWasmInitialized) {
24392 throw new Error("initializeWasm() must be awaited first!");
24394 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
24395 // debug statements here
24397 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
24399 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
24400 if(!isWasmInitialized) {
24401 throw new Error("initializeWasm() must be awaited first!");
24403 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
24404 return nativeResponseValue;
24406 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
24408 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
24409 if(!isWasmInitialized) {
24410 throw new Error("initializeWasm() must be awaited first!");
24412 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
24413 // debug statements here
24415 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
24417 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
24418 if(!isWasmInitialized) {
24419 throw new Error("initializeWasm() must be awaited first!");
24421 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
24422 return nativeResponseValue;
24424 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
24426 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
24427 if(!isWasmInitialized) {
24428 throw new Error("initializeWasm() must be awaited first!");
24430 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
24431 return nativeResponseValue;
24433 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
24435 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
24436 if(!isWasmInitialized) {
24437 throw new Error("initializeWasm() must be awaited first!");
24439 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
24440 return nativeResponseValue;
24442 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
24444 export function GossipTimestampFilter_free(this_obj: bigint): void {
24445 if(!isWasmInitialized) {
24446 throw new Error("initializeWasm() must be awaited first!");
24448 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
24449 // debug statements here
24451 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
24453 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
24454 if(!isWasmInitialized) {
24455 throw new Error("initializeWasm() must be awaited first!");
24457 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
24458 return nativeResponseValue;
24460 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24462 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
24463 if(!isWasmInitialized) {
24464 throw new Error("initializeWasm() must be awaited first!");
24466 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
24467 // debug statements here
24469 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
24471 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
24472 if(!isWasmInitialized) {
24473 throw new Error("initializeWasm() must be awaited first!");
24475 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
24476 return nativeResponseValue;
24478 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
24480 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
24481 if(!isWasmInitialized) {
24482 throw new Error("initializeWasm() must be awaited first!");
24484 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
24485 // debug statements here
24487 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
24489 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
24490 if(!isWasmInitialized) {
24491 throw new Error("initializeWasm() must be awaited first!");
24493 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
24494 return nativeResponseValue;
24496 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
24498 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
24499 if(!isWasmInitialized) {
24500 throw new Error("initializeWasm() must be awaited first!");
24502 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
24503 // debug statements here
24505 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
24507 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
24508 if(!isWasmInitialized) {
24509 throw new Error("initializeWasm() must be awaited first!");
24511 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
24512 return nativeResponseValue;
24514 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
24516 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
24517 if(!isWasmInitialized) {
24518 throw new Error("initializeWasm() must be awaited first!");
24520 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
24521 return nativeResponseValue;
24523 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
24525 export function GossipTimestampFilter_clone(orig: bigint): bigint {
24526 if(!isWasmInitialized) {
24527 throw new Error("initializeWasm() must be awaited first!");
24529 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
24530 return nativeResponseValue;
24532 // void ErrorAction_free(struct LDKErrorAction this_ptr);
24534 export function ErrorAction_free(this_ptr: bigint): void {
24535 if(!isWasmInitialized) {
24536 throw new Error("initializeWasm() must be awaited first!");
24538 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
24539 // debug statements here
24541 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
24543 export function ErrorAction_clone_ptr(arg: bigint): bigint {
24544 if(!isWasmInitialized) {
24545 throw new Error("initializeWasm() must be awaited first!");
24547 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
24548 return nativeResponseValue;
24550 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
24552 export function ErrorAction_clone(orig: bigint): bigint {
24553 if(!isWasmInitialized) {
24554 throw new Error("initializeWasm() must be awaited first!");
24556 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
24557 return nativeResponseValue;
24559 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
24561 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
24562 if(!isWasmInitialized) {
24563 throw new Error("initializeWasm() must be awaited first!");
24565 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
24566 return nativeResponseValue;
24568 // struct LDKErrorAction ErrorAction_ignore_error(void);
24570 export function ErrorAction_ignore_error(): bigint {
24571 if(!isWasmInitialized) {
24572 throw new Error("initializeWasm() must be awaited first!");
24574 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
24575 return nativeResponseValue;
24577 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
24579 export function ErrorAction_ignore_and_log(a: Level): bigint {
24580 if(!isWasmInitialized) {
24581 throw new Error("initializeWasm() must be awaited first!");
24583 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
24584 return nativeResponseValue;
24586 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
24588 export function ErrorAction_ignore_duplicate_gossip(): bigint {
24589 if(!isWasmInitialized) {
24590 throw new Error("initializeWasm() must be awaited first!");
24592 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
24593 return nativeResponseValue;
24595 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
24597 export function ErrorAction_send_error_message(msg: bigint): bigint {
24598 if(!isWasmInitialized) {
24599 throw new Error("initializeWasm() must be awaited first!");
24601 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
24602 return nativeResponseValue;
24604 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
24606 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
24607 if(!isWasmInitialized) {
24608 throw new Error("initializeWasm() must be awaited first!");
24610 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
24611 return nativeResponseValue;
24613 // void LightningError_free(struct LDKLightningError this_obj);
24615 export function LightningError_free(this_obj: bigint): void {
24616 if(!isWasmInitialized) {
24617 throw new Error("initializeWasm() must be awaited first!");
24619 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
24620 // debug statements here
24622 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
24624 export function LightningError_get_err(this_ptr: bigint): number {
24625 if(!isWasmInitialized) {
24626 throw new Error("initializeWasm() must be awaited first!");
24628 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
24629 return nativeResponseValue;
24631 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
24633 export function LightningError_set_err(this_ptr: bigint, val: number): void {
24634 if(!isWasmInitialized) {
24635 throw new Error("initializeWasm() must be awaited first!");
24637 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
24638 // debug statements here
24640 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
24642 export function LightningError_get_action(this_ptr: bigint): bigint {
24643 if(!isWasmInitialized) {
24644 throw new Error("initializeWasm() must be awaited first!");
24646 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
24647 return nativeResponseValue;
24649 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
24651 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
24652 if(!isWasmInitialized) {
24653 throw new Error("initializeWasm() must be awaited first!");
24655 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
24656 // debug statements here
24658 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
24660 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
24661 if(!isWasmInitialized) {
24662 throw new Error("initializeWasm() must be awaited first!");
24664 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
24665 return nativeResponseValue;
24667 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
24669 export function LightningError_clone_ptr(arg: bigint): bigint {
24670 if(!isWasmInitialized) {
24671 throw new Error("initializeWasm() must be awaited first!");
24673 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
24674 return nativeResponseValue;
24676 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
24678 export function LightningError_clone(orig: bigint): bigint {
24679 if(!isWasmInitialized) {
24680 throw new Error("initializeWasm() must be awaited first!");
24682 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
24683 return nativeResponseValue;
24685 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
24687 export function CommitmentUpdate_free(this_obj: bigint): void {
24688 if(!isWasmInitialized) {
24689 throw new Error("initializeWasm() must be awaited first!");
24691 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
24692 // debug statements here
24694 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24696 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
24697 if(!isWasmInitialized) {
24698 throw new Error("initializeWasm() must be awaited first!");
24700 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
24701 return nativeResponseValue;
24703 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
24705 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
24706 if(!isWasmInitialized) {
24707 throw new Error("initializeWasm() must be awaited first!");
24709 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
24710 // debug statements here
24712 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24714 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
24715 if(!isWasmInitialized) {
24716 throw new Error("initializeWasm() must be awaited first!");
24718 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
24719 return nativeResponseValue;
24721 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
24723 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
24724 if(!isWasmInitialized) {
24725 throw new Error("initializeWasm() must be awaited first!");
24727 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
24728 // debug statements here
24730 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24732 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
24733 if(!isWasmInitialized) {
24734 throw new Error("initializeWasm() must be awaited first!");
24736 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
24737 return nativeResponseValue;
24739 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
24741 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
24742 if(!isWasmInitialized) {
24743 throw new Error("initializeWasm() must be awaited first!");
24745 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
24746 // debug statements here
24748 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24750 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
24751 if(!isWasmInitialized) {
24752 throw new Error("initializeWasm() must be awaited first!");
24754 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
24755 return nativeResponseValue;
24757 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
24759 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
24760 if(!isWasmInitialized) {
24761 throw new Error("initializeWasm() must be awaited first!");
24763 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
24764 // debug statements here
24766 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24768 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
24769 if(!isWasmInitialized) {
24770 throw new Error("initializeWasm() must be awaited first!");
24772 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
24773 return nativeResponseValue;
24775 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
24777 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
24778 if(!isWasmInitialized) {
24779 throw new Error("initializeWasm() must be awaited first!");
24781 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
24782 // debug statements here
24784 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24786 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
24787 if(!isWasmInitialized) {
24788 throw new Error("initializeWasm() must be awaited first!");
24790 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
24791 return nativeResponseValue;
24793 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
24795 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
24796 if(!isWasmInitialized) {
24797 throw new Error("initializeWasm() must be awaited first!");
24799 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
24800 // debug statements here
24802 // 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);
24804 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 {
24805 if(!isWasmInitialized) {
24806 throw new Error("initializeWasm() must be awaited first!");
24808 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);
24809 return nativeResponseValue;
24811 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
24813 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
24814 if(!isWasmInitialized) {
24815 throw new Error("initializeWasm() must be awaited first!");
24817 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
24818 return nativeResponseValue;
24820 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
24822 export function CommitmentUpdate_clone(orig: bigint): bigint {
24823 if(!isWasmInitialized) {
24824 throw new Error("initializeWasm() must be awaited first!");
24826 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
24827 return nativeResponseValue;
24829 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
24831 export function ChannelMessageHandler_free(this_ptr: bigint): void {
24832 if(!isWasmInitialized) {
24833 throw new Error("initializeWasm() must be awaited first!");
24835 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
24836 // debug statements here
24838 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
24840 export function RoutingMessageHandler_free(this_ptr: bigint): void {
24841 if(!isWasmInitialized) {
24842 throw new Error("initializeWasm() must be awaited first!");
24844 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
24845 // debug statements here
24847 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
24849 export function AcceptChannel_write(obj: bigint): number {
24850 if(!isWasmInitialized) {
24851 throw new Error("initializeWasm() must be awaited first!");
24853 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
24854 return nativeResponseValue;
24856 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
24858 export function AcceptChannel_read(ser: number): bigint {
24859 if(!isWasmInitialized) {
24860 throw new Error("initializeWasm() must be awaited first!");
24862 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
24863 return nativeResponseValue;
24865 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
24867 export function AnnouncementSignatures_write(obj: bigint): number {
24868 if(!isWasmInitialized) {
24869 throw new Error("initializeWasm() must be awaited first!");
24871 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24872 return nativeResponseValue;
24874 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24876 export function AnnouncementSignatures_read(ser: number): bigint {
24877 if(!isWasmInitialized) {
24878 throw new Error("initializeWasm() must be awaited first!");
24880 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24881 return nativeResponseValue;
24883 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24885 export function ChannelReestablish_write(obj: bigint): number {
24886 if(!isWasmInitialized) {
24887 throw new Error("initializeWasm() must be awaited first!");
24889 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24890 return nativeResponseValue;
24892 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24894 export function ChannelReestablish_read(ser: number): bigint {
24895 if(!isWasmInitialized) {
24896 throw new Error("initializeWasm() must be awaited first!");
24898 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24899 return nativeResponseValue;
24901 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24903 export function ClosingSigned_write(obj: bigint): number {
24904 if(!isWasmInitialized) {
24905 throw new Error("initializeWasm() must be awaited first!");
24907 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24908 return nativeResponseValue;
24910 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24912 export function ClosingSigned_read(ser: number): bigint {
24913 if(!isWasmInitialized) {
24914 throw new Error("initializeWasm() must be awaited first!");
24916 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24917 return nativeResponseValue;
24919 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24921 export function ClosingSignedFeeRange_write(obj: bigint): number {
24922 if(!isWasmInitialized) {
24923 throw new Error("initializeWasm() must be awaited first!");
24925 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24926 return nativeResponseValue;
24928 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24930 export function ClosingSignedFeeRange_read(ser: number): bigint {
24931 if(!isWasmInitialized) {
24932 throw new Error("initializeWasm() must be awaited first!");
24934 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24935 return nativeResponseValue;
24937 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24939 export function CommitmentSigned_write(obj: bigint): number {
24940 if(!isWasmInitialized) {
24941 throw new Error("initializeWasm() must be awaited first!");
24943 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24944 return nativeResponseValue;
24946 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24948 export function CommitmentSigned_read(ser: number): bigint {
24949 if(!isWasmInitialized) {
24950 throw new Error("initializeWasm() must be awaited first!");
24952 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24953 return nativeResponseValue;
24955 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24957 export function FundingCreated_write(obj: bigint): number {
24958 if(!isWasmInitialized) {
24959 throw new Error("initializeWasm() must be awaited first!");
24961 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24962 return nativeResponseValue;
24964 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24966 export function FundingCreated_read(ser: number): bigint {
24967 if(!isWasmInitialized) {
24968 throw new Error("initializeWasm() must be awaited first!");
24970 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24971 return nativeResponseValue;
24973 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24975 export function FundingSigned_write(obj: bigint): number {
24976 if(!isWasmInitialized) {
24977 throw new Error("initializeWasm() must be awaited first!");
24979 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24980 return nativeResponseValue;
24982 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24984 export function FundingSigned_read(ser: number): bigint {
24985 if(!isWasmInitialized) {
24986 throw new Error("initializeWasm() must be awaited first!");
24988 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24989 return nativeResponseValue;
24991 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24993 export function ChannelReady_write(obj: bigint): number {
24994 if(!isWasmInitialized) {
24995 throw new Error("initializeWasm() must be awaited first!");
24997 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24998 return nativeResponseValue;
25000 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
25002 export function ChannelReady_read(ser: number): bigint {
25003 if(!isWasmInitialized) {
25004 throw new Error("initializeWasm() must be awaited first!");
25006 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
25007 return nativeResponseValue;
25009 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
25011 export function Init_write(obj: bigint): number {
25012 if(!isWasmInitialized) {
25013 throw new Error("initializeWasm() must be awaited first!");
25015 const nativeResponseValue = wasm.TS_Init_write(obj);
25016 return nativeResponseValue;
25018 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
25020 export function Init_read(ser: number): bigint {
25021 if(!isWasmInitialized) {
25022 throw new Error("initializeWasm() must be awaited first!");
25024 const nativeResponseValue = wasm.TS_Init_read(ser);
25025 return nativeResponseValue;
25027 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
25029 export function OpenChannel_write(obj: bigint): number {
25030 if(!isWasmInitialized) {
25031 throw new Error("initializeWasm() must be awaited first!");
25033 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
25034 return nativeResponseValue;
25036 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
25038 export function OpenChannel_read(ser: number): bigint {
25039 if(!isWasmInitialized) {
25040 throw new Error("initializeWasm() must be awaited first!");
25042 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
25043 return nativeResponseValue;
25045 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
25047 export function RevokeAndACK_write(obj: bigint): number {
25048 if(!isWasmInitialized) {
25049 throw new Error("initializeWasm() must be awaited first!");
25051 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
25052 return nativeResponseValue;
25054 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
25056 export function RevokeAndACK_read(ser: number): bigint {
25057 if(!isWasmInitialized) {
25058 throw new Error("initializeWasm() must be awaited first!");
25060 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
25061 return nativeResponseValue;
25063 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
25065 export function Shutdown_write(obj: bigint): number {
25066 if(!isWasmInitialized) {
25067 throw new Error("initializeWasm() must be awaited first!");
25069 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
25070 return nativeResponseValue;
25072 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
25074 export function Shutdown_read(ser: number): bigint {
25075 if(!isWasmInitialized) {
25076 throw new Error("initializeWasm() must be awaited first!");
25078 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
25079 return nativeResponseValue;
25081 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
25083 export function UpdateFailHTLC_write(obj: bigint): number {
25084 if(!isWasmInitialized) {
25085 throw new Error("initializeWasm() must be awaited first!");
25087 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
25088 return nativeResponseValue;
25090 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
25092 export function UpdateFailHTLC_read(ser: number): bigint {
25093 if(!isWasmInitialized) {
25094 throw new Error("initializeWasm() must be awaited first!");
25096 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
25097 return nativeResponseValue;
25099 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
25101 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
25102 if(!isWasmInitialized) {
25103 throw new Error("initializeWasm() must be awaited first!");
25105 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
25106 return nativeResponseValue;
25108 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
25110 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
25111 if(!isWasmInitialized) {
25112 throw new Error("initializeWasm() must be awaited first!");
25114 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
25115 return nativeResponseValue;
25117 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
25119 export function UpdateFee_write(obj: bigint): number {
25120 if(!isWasmInitialized) {
25121 throw new Error("initializeWasm() must be awaited first!");
25123 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
25124 return nativeResponseValue;
25126 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
25128 export function UpdateFee_read(ser: number): bigint {
25129 if(!isWasmInitialized) {
25130 throw new Error("initializeWasm() must be awaited first!");
25132 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
25133 return nativeResponseValue;
25135 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
25137 export function UpdateFulfillHTLC_write(obj: bigint): number {
25138 if(!isWasmInitialized) {
25139 throw new Error("initializeWasm() must be awaited first!");
25141 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
25142 return nativeResponseValue;
25144 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
25146 export function UpdateFulfillHTLC_read(ser: number): bigint {
25147 if(!isWasmInitialized) {
25148 throw new Error("initializeWasm() must be awaited first!");
25150 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
25151 return nativeResponseValue;
25153 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
25155 export function UpdateAddHTLC_write(obj: bigint): number {
25156 if(!isWasmInitialized) {
25157 throw new Error("initializeWasm() must be awaited first!");
25159 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
25160 return nativeResponseValue;
25162 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
25164 export function UpdateAddHTLC_read(ser: number): bigint {
25165 if(!isWasmInitialized) {
25166 throw new Error("initializeWasm() must be awaited first!");
25168 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
25169 return nativeResponseValue;
25171 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
25173 export function Ping_write(obj: bigint): number {
25174 if(!isWasmInitialized) {
25175 throw new Error("initializeWasm() must be awaited first!");
25177 const nativeResponseValue = wasm.TS_Ping_write(obj);
25178 return nativeResponseValue;
25180 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
25182 export function Ping_read(ser: number): bigint {
25183 if(!isWasmInitialized) {
25184 throw new Error("initializeWasm() must be awaited first!");
25186 const nativeResponseValue = wasm.TS_Ping_read(ser);
25187 return nativeResponseValue;
25189 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
25191 export function Pong_write(obj: bigint): number {
25192 if(!isWasmInitialized) {
25193 throw new Error("initializeWasm() must be awaited first!");
25195 const nativeResponseValue = wasm.TS_Pong_write(obj);
25196 return nativeResponseValue;
25198 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
25200 export function Pong_read(ser: number): bigint {
25201 if(!isWasmInitialized) {
25202 throw new Error("initializeWasm() must be awaited first!");
25204 const nativeResponseValue = wasm.TS_Pong_read(ser);
25205 return nativeResponseValue;
25207 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
25209 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
25210 if(!isWasmInitialized) {
25211 throw new Error("initializeWasm() must be awaited first!");
25213 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
25214 return nativeResponseValue;
25216 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
25218 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
25219 if(!isWasmInitialized) {
25220 throw new Error("initializeWasm() must be awaited first!");
25222 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
25223 return nativeResponseValue;
25225 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
25227 export function ChannelAnnouncement_write(obj: bigint): number {
25228 if(!isWasmInitialized) {
25229 throw new Error("initializeWasm() must be awaited first!");
25231 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
25232 return nativeResponseValue;
25234 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
25236 export function ChannelAnnouncement_read(ser: number): bigint {
25237 if(!isWasmInitialized) {
25238 throw new Error("initializeWasm() must be awaited first!");
25240 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
25241 return nativeResponseValue;
25243 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
25245 export function UnsignedChannelUpdate_write(obj: bigint): number {
25246 if(!isWasmInitialized) {
25247 throw new Error("initializeWasm() must be awaited first!");
25249 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
25250 return nativeResponseValue;
25252 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
25254 export function UnsignedChannelUpdate_read(ser: number): bigint {
25255 if(!isWasmInitialized) {
25256 throw new Error("initializeWasm() must be awaited first!");
25258 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
25259 return nativeResponseValue;
25261 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
25263 export function ChannelUpdate_write(obj: bigint): number {
25264 if(!isWasmInitialized) {
25265 throw new Error("initializeWasm() must be awaited first!");
25267 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
25268 return nativeResponseValue;
25270 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
25272 export function ChannelUpdate_read(ser: number): bigint {
25273 if(!isWasmInitialized) {
25274 throw new Error("initializeWasm() must be awaited first!");
25276 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
25277 return nativeResponseValue;
25279 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
25281 export function ErrorMessage_write(obj: bigint): number {
25282 if(!isWasmInitialized) {
25283 throw new Error("initializeWasm() must be awaited first!");
25285 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
25286 return nativeResponseValue;
25288 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
25290 export function ErrorMessage_read(ser: number): bigint {
25291 if(!isWasmInitialized) {
25292 throw new Error("initializeWasm() must be awaited first!");
25294 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
25295 return nativeResponseValue;
25297 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
25299 export function WarningMessage_write(obj: bigint): number {
25300 if(!isWasmInitialized) {
25301 throw new Error("initializeWasm() must be awaited first!");
25303 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
25304 return nativeResponseValue;
25306 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
25308 export function WarningMessage_read(ser: number): bigint {
25309 if(!isWasmInitialized) {
25310 throw new Error("initializeWasm() must be awaited first!");
25312 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
25313 return nativeResponseValue;
25315 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
25317 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
25318 if(!isWasmInitialized) {
25319 throw new Error("initializeWasm() must be awaited first!");
25321 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
25322 return nativeResponseValue;
25324 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
25326 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
25327 if(!isWasmInitialized) {
25328 throw new Error("initializeWasm() must be awaited first!");
25330 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
25331 return nativeResponseValue;
25333 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
25335 export function NodeAnnouncement_write(obj: bigint): number {
25336 if(!isWasmInitialized) {
25337 throw new Error("initializeWasm() must be awaited first!");
25339 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
25340 return nativeResponseValue;
25342 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
25344 export function NodeAnnouncement_read(ser: number): bigint {
25345 if(!isWasmInitialized) {
25346 throw new Error("initializeWasm() must be awaited first!");
25348 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
25349 return nativeResponseValue;
25351 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
25353 export function QueryShortChannelIds_read(ser: number): bigint {
25354 if(!isWasmInitialized) {
25355 throw new Error("initializeWasm() must be awaited first!");
25357 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
25358 return nativeResponseValue;
25360 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
25362 export function QueryShortChannelIds_write(obj: bigint): number {
25363 if(!isWasmInitialized) {
25364 throw new Error("initializeWasm() must be awaited first!");
25366 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
25367 return nativeResponseValue;
25369 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
25371 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
25372 if(!isWasmInitialized) {
25373 throw new Error("initializeWasm() must be awaited first!");
25375 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
25376 return nativeResponseValue;
25378 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
25380 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
25381 if(!isWasmInitialized) {
25382 throw new Error("initializeWasm() must be awaited first!");
25384 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
25385 return nativeResponseValue;
25387 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
25389 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
25390 if(!isWasmInitialized) {
25391 throw new Error("initializeWasm() must be awaited first!");
25393 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
25394 return nativeResponseValue;
25396 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
25398 export function QueryChannelRange_write(obj: bigint): number {
25399 if(!isWasmInitialized) {
25400 throw new Error("initializeWasm() must be awaited first!");
25402 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
25403 return nativeResponseValue;
25405 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
25407 export function QueryChannelRange_read(ser: number): bigint {
25408 if(!isWasmInitialized) {
25409 throw new Error("initializeWasm() must be awaited first!");
25411 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
25412 return nativeResponseValue;
25414 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
25416 export function ReplyChannelRange_read(ser: number): bigint {
25417 if(!isWasmInitialized) {
25418 throw new Error("initializeWasm() must be awaited first!");
25420 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
25421 return nativeResponseValue;
25423 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
25425 export function ReplyChannelRange_write(obj: bigint): number {
25426 if(!isWasmInitialized) {
25427 throw new Error("initializeWasm() must be awaited first!");
25429 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
25430 return nativeResponseValue;
25432 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
25434 export function GossipTimestampFilter_write(obj: bigint): number {
25435 if(!isWasmInitialized) {
25436 throw new Error("initializeWasm() must be awaited first!");
25438 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
25439 return nativeResponseValue;
25441 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
25443 export function GossipTimestampFilter_read(ser: number): bigint {
25444 if(!isWasmInitialized) {
25445 throw new Error("initializeWasm() must be awaited first!");
25447 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
25448 return nativeResponseValue;
25450 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
25452 export function CustomMessageHandler_free(this_ptr: bigint): void {
25453 if(!isWasmInitialized) {
25454 throw new Error("initializeWasm() must be awaited first!");
25456 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
25457 // debug statements here
25459 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
25461 export function IgnoringMessageHandler_free(this_obj: bigint): void {
25462 if(!isWasmInitialized) {
25463 throw new Error("initializeWasm() must be awaited first!");
25465 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
25466 // debug statements here
25468 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
25470 export function IgnoringMessageHandler_new(): bigint {
25471 if(!isWasmInitialized) {
25472 throw new Error("initializeWasm() must be awaited first!");
25474 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
25475 return nativeResponseValue;
25477 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25479 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
25480 if(!isWasmInitialized) {
25481 throw new Error("initializeWasm() must be awaited first!");
25483 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
25484 return nativeResponseValue;
25486 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25488 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
25489 if(!isWasmInitialized) {
25490 throw new Error("initializeWasm() must be awaited first!");
25492 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
25493 return nativeResponseValue;
25495 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25497 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
25498 if(!isWasmInitialized) {
25499 throw new Error("initializeWasm() must be awaited first!");
25501 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
25502 return nativeResponseValue;
25504 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25506 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
25507 if(!isWasmInitialized) {
25508 throw new Error("initializeWasm() must be awaited first!");
25510 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
25511 return nativeResponseValue;
25513 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
25515 export function ErroringMessageHandler_free(this_obj: bigint): void {
25516 if(!isWasmInitialized) {
25517 throw new Error("initializeWasm() must be awaited first!");
25519 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
25520 // debug statements here
25522 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
25524 export function ErroringMessageHandler_new(): bigint {
25525 if(!isWasmInitialized) {
25526 throw new Error("initializeWasm() must be awaited first!");
25528 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
25529 return nativeResponseValue;
25531 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
25533 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
25534 if(!isWasmInitialized) {
25535 throw new Error("initializeWasm() must be awaited first!");
25537 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
25538 return nativeResponseValue;
25540 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
25542 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
25543 if(!isWasmInitialized) {
25544 throw new Error("initializeWasm() must be awaited first!");
25546 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
25547 return nativeResponseValue;
25549 // void MessageHandler_free(struct LDKMessageHandler this_obj);
25551 export function MessageHandler_free(this_obj: bigint): void {
25552 if(!isWasmInitialized) {
25553 throw new Error("initializeWasm() must be awaited first!");
25555 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
25556 // debug statements here
25558 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25560 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
25561 if(!isWasmInitialized) {
25562 throw new Error("initializeWasm() must be awaited first!");
25564 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
25565 return nativeResponseValue;
25567 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
25569 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
25570 if(!isWasmInitialized) {
25571 throw new Error("initializeWasm() must be awaited first!");
25573 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
25574 // debug statements here
25576 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25578 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
25579 if(!isWasmInitialized) {
25580 throw new Error("initializeWasm() must be awaited first!");
25582 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
25583 return nativeResponseValue;
25585 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
25587 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
25588 if(!isWasmInitialized) {
25589 throw new Error("initializeWasm() must be awaited first!");
25591 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
25592 // debug statements here
25594 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
25596 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint): bigint {
25597 if(!isWasmInitialized) {
25598 throw new Error("initializeWasm() must be awaited first!");
25600 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
25601 return nativeResponseValue;
25603 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
25605 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
25606 if(!isWasmInitialized) {
25607 throw new Error("initializeWasm() must be awaited first!");
25609 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
25610 return nativeResponseValue;
25612 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
25614 export function SocketDescriptor_clone(orig: bigint): bigint {
25615 if(!isWasmInitialized) {
25616 throw new Error("initializeWasm() must be awaited first!");
25618 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
25619 return nativeResponseValue;
25621 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
25623 export function SocketDescriptor_free(this_ptr: bigint): void {
25624 if(!isWasmInitialized) {
25625 throw new Error("initializeWasm() must be awaited first!");
25627 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
25628 // debug statements here
25630 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
25632 export function PeerHandleError_free(this_obj: bigint): void {
25633 if(!isWasmInitialized) {
25634 throw new Error("initializeWasm() must be awaited first!");
25636 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
25637 // debug statements here
25639 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
25641 export function PeerHandleError_get_no_connection_possible(this_ptr: bigint): boolean {
25642 if(!isWasmInitialized) {
25643 throw new Error("initializeWasm() must be awaited first!");
25645 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
25646 return nativeResponseValue;
25648 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
25650 export function PeerHandleError_set_no_connection_possible(this_ptr: bigint, val: boolean): void {
25651 if(!isWasmInitialized) {
25652 throw new Error("initializeWasm() must be awaited first!");
25654 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
25655 // debug statements here
25657 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
25659 export function PeerHandleError_new(no_connection_possible_arg: boolean): bigint {
25660 if(!isWasmInitialized) {
25661 throw new Error("initializeWasm() must be awaited first!");
25663 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
25664 return nativeResponseValue;
25666 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
25668 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
25669 if(!isWasmInitialized) {
25670 throw new Error("initializeWasm() must be awaited first!");
25672 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
25673 return nativeResponseValue;
25675 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
25677 export function PeerHandleError_clone(orig: bigint): bigint {
25678 if(!isWasmInitialized) {
25679 throw new Error("initializeWasm() must be awaited first!");
25681 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
25682 return nativeResponseValue;
25684 // void PeerManager_free(struct LDKPeerManager this_obj);
25686 export function PeerManager_free(this_obj: bigint): void {
25687 if(!isWasmInitialized) {
25688 throw new Error("initializeWasm() must be awaited first!");
25690 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
25691 // debug statements here
25693 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler);
25695 export function PeerManager_new(message_handler: bigint, our_node_secret: number, ephemeral_random_data: number, logger: bigint, custom_message_handler: bigint): bigint {
25696 if(!isWasmInitialized) {
25697 throw new Error("initializeWasm() must be awaited first!");
25699 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
25700 return nativeResponseValue;
25702 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
25704 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
25705 if(!isWasmInitialized) {
25706 throw new Error("initializeWasm() must be awaited first!");
25708 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
25709 return nativeResponseValue;
25711 // MUST_USE_RES struct LDKCResult_CVec_u8ZPeerHandleErrorZ PeerManager_new_outbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKSocketDescriptor descriptor, struct LDKCOption_NetAddressZ remote_network_address);
25713 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
25714 if(!isWasmInitialized) {
25715 throw new Error("initializeWasm() must be awaited first!");
25717 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
25718 return nativeResponseValue;
25720 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor, struct LDKCOption_NetAddressZ remote_network_address);
25722 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
25723 if(!isWasmInitialized) {
25724 throw new Error("initializeWasm() must be awaited first!");
25726 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
25727 return nativeResponseValue;
25729 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25731 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
25732 if(!isWasmInitialized) {
25733 throw new Error("initializeWasm() must be awaited first!");
25735 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
25736 return nativeResponseValue;
25738 // 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);
25740 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
25741 if(!isWasmInitialized) {
25742 throw new Error("initializeWasm() must be awaited first!");
25744 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
25745 return nativeResponseValue;
25747 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
25749 export function PeerManager_process_events(this_arg: bigint): void {
25750 if(!isWasmInitialized) {
25751 throw new Error("initializeWasm() must be awaited first!");
25753 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
25754 // debug statements here
25756 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25758 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
25759 if(!isWasmInitialized) {
25760 throw new Error("initializeWasm() must be awaited first!");
25762 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
25763 // debug statements here
25765 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
25767 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number, no_connection_possible: boolean): void {
25768 if(!isWasmInitialized) {
25769 throw new Error("initializeWasm() must be awaited first!");
25771 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
25772 // debug statements here
25774 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
25776 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
25777 if(!isWasmInitialized) {
25778 throw new Error("initializeWasm() must be awaited first!");
25780 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
25781 // debug statements here
25783 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
25785 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
25786 if(!isWasmInitialized) {
25787 throw new Error("initializeWasm() must be awaited first!");
25789 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
25790 // debug statements here
25792 // uint64_t htlc_success_tx_weight(bool opt_anchors);
25794 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
25795 if(!isWasmInitialized) {
25796 throw new Error("initializeWasm() must be awaited first!");
25798 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
25799 return nativeResponseValue;
25801 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
25803 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
25804 if(!isWasmInitialized) {
25805 throw new Error("initializeWasm() must be awaited first!");
25807 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
25808 return nativeResponseValue;
25810 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
25812 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
25813 if(!isWasmInitialized) {
25814 throw new Error("initializeWasm() must be awaited first!");
25816 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
25817 return nativeResponseValue;
25819 // 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);
25821 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 {
25822 if(!isWasmInitialized) {
25823 throw new Error("initializeWasm() must be awaited first!");
25825 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25826 return nativeResponseValue;
25828 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
25830 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
25831 if(!isWasmInitialized) {
25832 throw new Error("initializeWasm() must be awaited first!");
25834 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
25835 // debug statements here
25837 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
25839 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
25840 if(!isWasmInitialized) {
25841 throw new Error("initializeWasm() must be awaited first!");
25843 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
25844 return nativeResponseValue;
25846 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
25848 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
25849 if(!isWasmInitialized) {
25850 throw new Error("initializeWasm() must be awaited first!");
25852 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
25853 return nativeResponseValue;
25855 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
25857 export function CounterpartyCommitmentSecrets_new(): bigint {
25858 if(!isWasmInitialized) {
25859 throw new Error("initializeWasm() must be awaited first!");
25861 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
25862 return nativeResponseValue;
25864 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
25866 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
25867 if(!isWasmInitialized) {
25868 throw new Error("initializeWasm() must be awaited first!");
25870 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25871 return nativeResponseValue;
25873 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25875 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
25876 if(!isWasmInitialized) {
25877 throw new Error("initializeWasm() must be awaited first!");
25879 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25880 return nativeResponseValue;
25882 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25884 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
25885 if(!isWasmInitialized) {
25886 throw new Error("initializeWasm() must be awaited first!");
25888 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25889 return nativeResponseValue;
25891 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25893 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
25894 if(!isWasmInitialized) {
25895 throw new Error("initializeWasm() must be awaited first!");
25897 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25898 return nativeResponseValue;
25900 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25902 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
25903 if(!isWasmInitialized) {
25904 throw new Error("initializeWasm() must be awaited first!");
25906 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25907 return nativeResponseValue;
25909 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25911 export function derive_private_key(per_commitment_point: number, base_secret: number): bigint {
25912 if(!isWasmInitialized) {
25913 throw new Error("initializeWasm() must be awaited first!");
25915 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25916 return nativeResponseValue;
25918 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25920 export function derive_public_key(per_commitment_point: number, base_point: number): bigint {
25921 if(!isWasmInitialized) {
25922 throw new Error("initializeWasm() must be awaited first!");
25924 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25925 return nativeResponseValue;
25927 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25929 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): bigint {
25930 if(!isWasmInitialized) {
25931 throw new Error("initializeWasm() must be awaited first!");
25933 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25934 return nativeResponseValue;
25936 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25938 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): bigint {
25939 if(!isWasmInitialized) {
25940 throw new Error("initializeWasm() must be awaited first!");
25942 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25943 return nativeResponseValue;
25945 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25947 export function TxCreationKeys_free(this_obj: bigint): void {
25948 if(!isWasmInitialized) {
25949 throw new Error("initializeWasm() must be awaited first!");
25951 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25952 // debug statements here
25954 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25956 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
25957 if(!isWasmInitialized) {
25958 throw new Error("initializeWasm() must be awaited first!");
25960 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25961 return nativeResponseValue;
25963 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25965 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
25966 if(!isWasmInitialized) {
25967 throw new Error("initializeWasm() must be awaited first!");
25969 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25970 // debug statements here
25972 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25974 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
25975 if(!isWasmInitialized) {
25976 throw new Error("initializeWasm() must be awaited first!");
25978 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25979 return nativeResponseValue;
25981 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25983 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
25984 if(!isWasmInitialized) {
25985 throw new Error("initializeWasm() must be awaited first!");
25987 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25988 // debug statements here
25990 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25992 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
25993 if(!isWasmInitialized) {
25994 throw new Error("initializeWasm() must be awaited first!");
25996 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25997 return nativeResponseValue;
25999 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26001 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
26002 if(!isWasmInitialized) {
26003 throw new Error("initializeWasm() must be awaited first!");
26005 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
26006 // debug statements here
26008 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
26010 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
26011 if(!isWasmInitialized) {
26012 throw new Error("initializeWasm() must be awaited first!");
26014 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
26015 return nativeResponseValue;
26017 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26019 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
26020 if(!isWasmInitialized) {
26021 throw new Error("initializeWasm() must be awaited first!");
26023 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
26024 // debug statements here
26026 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
26028 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
26029 if(!isWasmInitialized) {
26030 throw new Error("initializeWasm() must be awaited first!");
26032 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
26033 return nativeResponseValue;
26035 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26037 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
26038 if(!isWasmInitialized) {
26039 throw new Error("initializeWasm() must be awaited first!");
26041 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
26042 // debug statements here
26044 // 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);
26046 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 {
26047 if(!isWasmInitialized) {
26048 throw new Error("initializeWasm() must be awaited first!");
26050 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);
26051 return nativeResponseValue;
26053 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
26055 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
26056 if(!isWasmInitialized) {
26057 throw new Error("initializeWasm() must be awaited first!");
26059 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
26060 return nativeResponseValue;
26062 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
26064 export function TxCreationKeys_clone(orig: bigint): bigint {
26065 if(!isWasmInitialized) {
26066 throw new Error("initializeWasm() must be awaited first!");
26068 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
26069 return nativeResponseValue;
26071 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
26073 export function TxCreationKeys_write(obj: bigint): number {
26074 if(!isWasmInitialized) {
26075 throw new Error("initializeWasm() must be awaited first!");
26077 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
26078 return nativeResponseValue;
26080 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
26082 export function TxCreationKeys_read(ser: number): bigint {
26083 if(!isWasmInitialized) {
26084 throw new Error("initializeWasm() must be awaited first!");
26086 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
26087 return nativeResponseValue;
26089 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
26091 export function ChannelPublicKeys_free(this_obj: bigint): void {
26092 if(!isWasmInitialized) {
26093 throw new Error("initializeWasm() must be awaited first!");
26095 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
26096 // debug statements here
26098 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26100 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
26101 if(!isWasmInitialized) {
26102 throw new Error("initializeWasm() must be awaited first!");
26104 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
26105 return nativeResponseValue;
26107 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26109 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
26110 if(!isWasmInitialized) {
26111 throw new Error("initializeWasm() must be awaited first!");
26113 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
26114 // debug statements here
26116 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26118 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
26119 if(!isWasmInitialized) {
26120 throw new Error("initializeWasm() must be awaited first!");
26122 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
26123 return nativeResponseValue;
26125 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26127 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
26128 if(!isWasmInitialized) {
26129 throw new Error("initializeWasm() must be awaited first!");
26131 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
26132 // debug statements here
26134 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26136 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
26137 if(!isWasmInitialized) {
26138 throw new Error("initializeWasm() must be awaited first!");
26140 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
26141 return nativeResponseValue;
26143 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26145 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
26146 if(!isWasmInitialized) {
26147 throw new Error("initializeWasm() must be awaited first!");
26149 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
26150 // debug statements here
26152 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26154 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
26155 if(!isWasmInitialized) {
26156 throw new Error("initializeWasm() must be awaited first!");
26158 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
26159 return nativeResponseValue;
26161 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26163 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
26164 if(!isWasmInitialized) {
26165 throw new Error("initializeWasm() must be awaited first!");
26167 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
26168 // debug statements here
26170 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26172 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
26173 if(!isWasmInitialized) {
26174 throw new Error("initializeWasm() must be awaited first!");
26176 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
26177 return nativeResponseValue;
26179 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26181 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
26182 if(!isWasmInitialized) {
26183 throw new Error("initializeWasm() must be awaited first!");
26185 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
26186 // debug statements here
26188 // 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);
26190 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 {
26191 if(!isWasmInitialized) {
26192 throw new Error("initializeWasm() must be awaited first!");
26194 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
26195 return nativeResponseValue;
26197 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
26199 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
26200 if(!isWasmInitialized) {
26201 throw new Error("initializeWasm() must be awaited first!");
26203 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
26204 return nativeResponseValue;
26206 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
26208 export function ChannelPublicKeys_clone(orig: bigint): bigint {
26209 if(!isWasmInitialized) {
26210 throw new Error("initializeWasm() must be awaited first!");
26212 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
26213 return nativeResponseValue;
26215 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
26217 export function ChannelPublicKeys_write(obj: bigint): number {
26218 if(!isWasmInitialized) {
26219 throw new Error("initializeWasm() must be awaited first!");
26221 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
26222 return nativeResponseValue;
26224 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
26226 export function ChannelPublicKeys_read(ser: number): bigint {
26227 if(!isWasmInitialized) {
26228 throw new Error("initializeWasm() must be awaited first!");
26230 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
26231 return nativeResponseValue;
26233 // MUST_USE_RES struct LDKCResult_TxCreationKeysErrorZ TxCreationKeys_derive_new(struct LDKPublicKey per_commitment_point, struct LDKPublicKey broadcaster_delayed_payment_base, struct LDKPublicKey broadcaster_htlc_base, struct LDKPublicKey countersignatory_revocation_base, struct LDKPublicKey countersignatory_htlc_base);
26235 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 {
26236 if(!isWasmInitialized) {
26237 throw new Error("initializeWasm() must be awaited first!");
26239 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
26240 return nativeResponseValue;
26242 // MUST_USE_RES struct LDKCResult_TxCreationKeysErrorZ TxCreationKeys_from_channel_static_keys(struct LDKPublicKey per_commitment_point, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
26244 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
26245 if(!isWasmInitialized) {
26246 throw new Error("initializeWasm() must be awaited first!");
26248 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
26249 return nativeResponseValue;
26251 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
26253 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
26254 if(!isWasmInitialized) {
26255 throw new Error("initializeWasm() must be awaited first!");
26257 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
26258 return nativeResponseValue;
26260 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
26262 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
26263 if(!isWasmInitialized) {
26264 throw new Error("initializeWasm() must be awaited first!");
26266 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
26267 // debug statements here
26269 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26271 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
26272 if(!isWasmInitialized) {
26273 throw new Error("initializeWasm() must be awaited first!");
26275 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
26276 return nativeResponseValue;
26278 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
26280 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
26281 if(!isWasmInitialized) {
26282 throw new Error("initializeWasm() must be awaited first!");
26284 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
26285 // debug statements here
26287 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26289 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
26290 if(!isWasmInitialized) {
26291 throw new Error("initializeWasm() must be awaited first!");
26293 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
26294 return nativeResponseValue;
26296 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
26298 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
26299 if(!isWasmInitialized) {
26300 throw new Error("initializeWasm() must be awaited first!");
26302 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
26303 // debug statements here
26305 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26307 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
26308 if(!isWasmInitialized) {
26309 throw new Error("initializeWasm() must be awaited first!");
26311 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
26312 return nativeResponseValue;
26314 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
26316 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
26317 if(!isWasmInitialized) {
26318 throw new Error("initializeWasm() must be awaited first!");
26320 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
26321 // debug statements here
26323 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
26325 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
26326 if(!isWasmInitialized) {
26327 throw new Error("initializeWasm() must be awaited first!");
26329 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
26330 return nativeResponseValue;
26332 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26334 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
26335 if(!isWasmInitialized) {
26336 throw new Error("initializeWasm() must be awaited first!");
26338 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
26339 // debug statements here
26341 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26343 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
26344 if(!isWasmInitialized) {
26345 throw new Error("initializeWasm() must be awaited first!");
26347 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
26348 return nativeResponseValue;
26350 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26352 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
26353 if(!isWasmInitialized) {
26354 throw new Error("initializeWasm() must be awaited first!");
26356 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
26357 // debug statements here
26359 // 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);
26361 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 {
26362 if(!isWasmInitialized) {
26363 throw new Error("initializeWasm() must be awaited first!");
26365 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
26366 return nativeResponseValue;
26368 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
26370 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
26371 if(!isWasmInitialized) {
26372 throw new Error("initializeWasm() must be awaited first!");
26374 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
26375 return nativeResponseValue;
26377 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
26379 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
26380 if(!isWasmInitialized) {
26381 throw new Error("initializeWasm() must be awaited first!");
26383 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
26384 return nativeResponseValue;
26386 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
26388 export function HTLCOutputInCommitment_write(obj: bigint): number {
26389 if(!isWasmInitialized) {
26390 throw new Error("initializeWasm() must be awaited first!");
26392 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
26393 return nativeResponseValue;
26395 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
26397 export function HTLCOutputInCommitment_read(ser: number): bigint {
26398 if(!isWasmInitialized) {
26399 throw new Error("initializeWasm() must be awaited first!");
26401 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
26402 return nativeResponseValue;
26404 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
26406 export function get_htlc_redeemscript(htlc: bigint, opt_anchors: boolean, keys: bigint): number {
26407 if(!isWasmInitialized) {
26408 throw new Error("initializeWasm() must be awaited first!");
26410 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
26411 return nativeResponseValue;
26413 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
26415 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
26416 if(!isWasmInitialized) {
26417 throw new Error("initializeWasm() must be awaited first!");
26419 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
26420 return nativeResponseValue;
26422 // struct LDKTransaction build_htlc_transaction(const uint8_t (*commitment_txid)[32], uint32_t feerate_per_kw, uint16_t contest_delay, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
26424 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, opt_anchors: boolean, broadcaster_delayed_payment_key: number, revocation_key: number): number {
26425 if(!isWasmInitialized) {
26426 throw new Error("initializeWasm() must be awaited first!");
26428 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
26429 return nativeResponseValue;
26431 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
26433 export function get_anchor_redeemscript(funding_pubkey: number): number {
26434 if(!isWasmInitialized) {
26435 throw new Error("initializeWasm() must be awaited first!");
26437 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
26438 return nativeResponseValue;
26440 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
26442 export function ChannelTransactionParameters_free(this_obj: bigint): void {
26443 if(!isWasmInitialized) {
26444 throw new Error("initializeWasm() must be awaited first!");
26446 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
26447 // debug statements here
26449 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26451 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
26452 if(!isWasmInitialized) {
26453 throw new Error("initializeWasm() must be awaited first!");
26455 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
26456 return nativeResponseValue;
26458 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26460 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
26461 if(!isWasmInitialized) {
26462 throw new Error("initializeWasm() must be awaited first!");
26464 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
26465 // debug statements here
26467 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26469 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
26470 if(!isWasmInitialized) {
26471 throw new Error("initializeWasm() must be awaited first!");
26473 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
26474 return nativeResponseValue;
26476 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26478 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
26479 if(!isWasmInitialized) {
26480 throw new Error("initializeWasm() must be awaited first!");
26482 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
26483 // debug statements here
26485 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26487 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
26488 if(!isWasmInitialized) {
26489 throw new Error("initializeWasm() must be awaited first!");
26491 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
26492 return nativeResponseValue;
26494 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
26496 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
26497 if(!isWasmInitialized) {
26498 throw new Error("initializeWasm() must be awaited first!");
26500 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
26501 // debug statements here
26503 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26505 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
26506 if(!isWasmInitialized) {
26507 throw new Error("initializeWasm() must be awaited first!");
26509 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
26510 return nativeResponseValue;
26512 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
26514 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
26515 if(!isWasmInitialized) {
26516 throw new Error("initializeWasm() must be awaited first!");
26518 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
26519 // debug statements here
26521 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26523 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
26524 if(!isWasmInitialized) {
26525 throw new Error("initializeWasm() must be awaited first!");
26527 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
26528 return nativeResponseValue;
26530 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
26532 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
26533 if(!isWasmInitialized) {
26534 throw new Error("initializeWasm() must be awaited first!");
26536 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
26537 // debug statements here
26539 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26541 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: bigint): COption_NoneZ {
26542 if(!isWasmInitialized) {
26543 throw new Error("initializeWasm() must be awaited first!");
26545 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
26546 return nativeResponseValue;
26548 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
26550 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: bigint, val: COption_NoneZ): void {
26551 if(!isWasmInitialized) {
26552 throw new Error("initializeWasm() must be awaited first!");
26554 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
26555 // debug statements here
26557 // MUST_USE_RES struct LDKChannelTransactionParameters ChannelTransactionParameters_new(struct LDKChannelPublicKeys holder_pubkeys_arg, uint16_t holder_selected_contest_delay_arg, bool is_outbound_from_holder_arg, struct LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg, struct LDKOutPoint funding_outpoint_arg, enum LDKCOption_NoneZ opt_anchors_arg);
26559 export function ChannelTransactionParameters_new(holder_pubkeys_arg: bigint, holder_selected_contest_delay_arg: number, is_outbound_from_holder_arg: boolean, counterparty_parameters_arg: bigint, funding_outpoint_arg: bigint, opt_anchors_arg: COption_NoneZ): bigint {
26560 if(!isWasmInitialized) {
26561 throw new Error("initializeWasm() must be awaited first!");
26563 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_new(holder_pubkeys_arg, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg, funding_outpoint_arg, opt_anchors_arg);
26564 return nativeResponseValue;
26566 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
26568 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
26569 if(!isWasmInitialized) {
26570 throw new Error("initializeWasm() must be awaited first!");
26572 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
26573 return nativeResponseValue;
26575 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
26577 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
26578 if(!isWasmInitialized) {
26579 throw new Error("initializeWasm() must be awaited first!");
26581 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
26582 return nativeResponseValue;
26584 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
26586 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
26587 if(!isWasmInitialized) {
26588 throw new Error("initializeWasm() must be awaited first!");
26590 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
26591 // debug statements here
26593 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26595 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
26596 if(!isWasmInitialized) {
26597 throw new Error("initializeWasm() must be awaited first!");
26599 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
26600 return nativeResponseValue;
26602 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26604 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
26605 if(!isWasmInitialized) {
26606 throw new Error("initializeWasm() must be awaited first!");
26608 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
26609 // debug statements here
26611 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26613 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
26614 if(!isWasmInitialized) {
26615 throw new Error("initializeWasm() must be awaited first!");
26617 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
26618 return nativeResponseValue;
26620 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26622 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
26623 if(!isWasmInitialized) {
26624 throw new Error("initializeWasm() must be awaited first!");
26626 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
26627 // debug statements here
26629 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
26631 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
26632 if(!isWasmInitialized) {
26633 throw new Error("initializeWasm() must be awaited first!");
26635 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
26636 return nativeResponseValue;
26638 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
26640 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
26641 if(!isWasmInitialized) {
26642 throw new Error("initializeWasm() must be awaited first!");
26644 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
26645 return nativeResponseValue;
26647 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
26649 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
26650 if(!isWasmInitialized) {
26651 throw new Error("initializeWasm() must be awaited first!");
26653 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
26654 return nativeResponseValue;
26656 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26658 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
26659 if(!isWasmInitialized) {
26660 throw new Error("initializeWasm() must be awaited first!");
26662 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
26663 return nativeResponseValue;
26665 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26667 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
26668 if(!isWasmInitialized) {
26669 throw new Error("initializeWasm() must be awaited first!");
26671 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
26672 return nativeResponseValue;
26674 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26676 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
26677 if(!isWasmInitialized) {
26678 throw new Error("initializeWasm() must be awaited first!");
26680 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
26681 return nativeResponseValue;
26683 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
26685 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
26686 if(!isWasmInitialized) {
26687 throw new Error("initializeWasm() must be awaited first!");
26689 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
26690 return nativeResponseValue;
26692 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
26694 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
26695 if(!isWasmInitialized) {
26696 throw new Error("initializeWasm() must be awaited first!");
26698 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
26699 return nativeResponseValue;
26701 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
26703 export function ChannelTransactionParameters_write(obj: bigint): number {
26704 if(!isWasmInitialized) {
26705 throw new Error("initializeWasm() must be awaited first!");
26707 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
26708 return nativeResponseValue;
26710 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
26712 export function ChannelTransactionParameters_read(ser: number): bigint {
26713 if(!isWasmInitialized) {
26714 throw new Error("initializeWasm() must be awaited first!");
26716 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
26717 return nativeResponseValue;
26719 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
26721 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
26722 if(!isWasmInitialized) {
26723 throw new Error("initializeWasm() must be awaited first!");
26725 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
26726 // debug statements here
26728 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26730 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
26731 if(!isWasmInitialized) {
26732 throw new Error("initializeWasm() must be awaited first!");
26734 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
26735 return nativeResponseValue;
26737 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26739 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
26740 if(!isWasmInitialized) {
26741 throw new Error("initializeWasm() must be awaited first!");
26743 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
26744 return nativeResponseValue;
26746 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26748 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
26749 if(!isWasmInitialized) {
26750 throw new Error("initializeWasm() must be awaited first!");
26752 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
26753 return nativeResponseValue;
26755 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26757 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
26758 if(!isWasmInitialized) {
26759 throw new Error("initializeWasm() must be awaited first!");
26761 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
26762 return nativeResponseValue;
26764 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26766 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
26767 if(!isWasmInitialized) {
26768 throw new Error("initializeWasm() must be awaited first!");
26770 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
26771 return nativeResponseValue;
26773 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26775 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: bigint): boolean {
26776 if(!isWasmInitialized) {
26777 throw new Error("initializeWasm() must be awaited first!");
26779 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
26780 return nativeResponseValue;
26782 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
26784 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
26785 if(!isWasmInitialized) {
26786 throw new Error("initializeWasm() must be awaited first!");
26788 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
26789 // debug statements here
26791 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26793 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
26794 if(!isWasmInitialized) {
26795 throw new Error("initializeWasm() must be awaited first!");
26797 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
26798 return nativeResponseValue;
26800 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
26802 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
26803 if(!isWasmInitialized) {
26804 throw new Error("initializeWasm() must be awaited first!");
26806 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
26807 // debug statements here
26809 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26811 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
26812 if(!isWasmInitialized) {
26813 throw new Error("initializeWasm() must be awaited first!");
26815 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
26816 return nativeResponseValue;
26818 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
26820 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
26821 if(!isWasmInitialized) {
26822 throw new Error("initializeWasm() must be awaited first!");
26824 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
26825 // debug statements here
26827 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
26829 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
26830 if(!isWasmInitialized) {
26831 throw new Error("initializeWasm() must be awaited first!");
26833 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
26834 return nativeResponseValue;
26836 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
26838 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
26839 if(!isWasmInitialized) {
26840 throw new Error("initializeWasm() must be awaited first!");
26842 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
26843 return nativeResponseValue;
26845 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
26847 export function HolderCommitmentTransaction_write(obj: bigint): number {
26848 if(!isWasmInitialized) {
26849 throw new Error("initializeWasm() must be awaited first!");
26851 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
26852 return nativeResponseValue;
26854 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
26856 export function HolderCommitmentTransaction_read(ser: number): bigint {
26857 if(!isWasmInitialized) {
26858 throw new Error("initializeWasm() must be awaited first!");
26860 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
26861 return nativeResponseValue;
26863 // MUST_USE_RES struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_new(struct LDKCommitmentTransaction commitment_tx, struct LDKSignature counterparty_sig, struct LDKCVec_SignatureZ counterparty_htlc_sigs, struct LDKPublicKey holder_funding_key, struct LDKPublicKey counterparty_funding_key);
26865 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
26866 if(!isWasmInitialized) {
26867 throw new Error("initializeWasm() must be awaited first!");
26869 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
26870 return nativeResponseValue;
26872 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
26874 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
26875 if(!isWasmInitialized) {
26876 throw new Error("initializeWasm() must be awaited first!");
26878 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
26879 // debug statements here
26881 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26883 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
26884 if(!isWasmInitialized) {
26885 throw new Error("initializeWasm() must be awaited first!");
26887 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26888 return nativeResponseValue;
26890 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26892 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
26893 if(!isWasmInitialized) {
26894 throw new Error("initializeWasm() must be awaited first!");
26896 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26897 // debug statements here
26899 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26901 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
26902 if(!isWasmInitialized) {
26903 throw new Error("initializeWasm() must be awaited first!");
26905 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26906 return nativeResponseValue;
26908 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26910 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
26911 if(!isWasmInitialized) {
26912 throw new Error("initializeWasm() must be awaited first!");
26914 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26915 // debug statements here
26917 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26919 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
26920 if(!isWasmInitialized) {
26921 throw new Error("initializeWasm() must be awaited first!");
26923 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26924 return nativeResponseValue;
26926 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26928 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
26929 if(!isWasmInitialized) {
26930 throw new Error("initializeWasm() must be awaited first!");
26932 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26933 return nativeResponseValue;
26935 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26937 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
26938 if(!isWasmInitialized) {
26939 throw new Error("initializeWasm() must be awaited first!");
26941 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26942 return nativeResponseValue;
26944 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26946 export function BuiltCommitmentTransaction_write(obj: bigint): number {
26947 if(!isWasmInitialized) {
26948 throw new Error("initializeWasm() must be awaited first!");
26950 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26951 return nativeResponseValue;
26953 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26955 export function BuiltCommitmentTransaction_read(ser: number): bigint {
26956 if(!isWasmInitialized) {
26957 throw new Error("initializeWasm() must be awaited first!");
26959 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26960 return nativeResponseValue;
26962 // 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);
26964 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26965 if(!isWasmInitialized) {
26966 throw new Error("initializeWasm() must be awaited first!");
26968 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26969 return nativeResponseValue;
26971 // MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
26973 export function BuiltCommitmentTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26974 if(!isWasmInitialized) {
26975 throw new Error("initializeWasm() must be awaited first!");
26977 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26978 return nativeResponseValue;
26980 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26982 export function ClosingTransaction_free(this_obj: bigint): void {
26983 if(!isWasmInitialized) {
26984 throw new Error("initializeWasm() must be awaited first!");
26986 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26987 // debug statements here
26989 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26991 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
26992 if(!isWasmInitialized) {
26993 throw new Error("initializeWasm() must be awaited first!");
26995 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26996 return nativeResponseValue;
26998 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
27000 export function ClosingTransaction_clone(orig: bigint): bigint {
27001 if(!isWasmInitialized) {
27002 throw new Error("initializeWasm() must be awaited first!");
27004 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
27005 return nativeResponseValue;
27007 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
27009 export function ClosingTransaction_hash(o: bigint): bigint {
27010 if(!isWasmInitialized) {
27011 throw new Error("initializeWasm() must be awaited first!");
27013 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
27014 return nativeResponseValue;
27016 // 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);
27018 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 {
27019 if(!isWasmInitialized) {
27020 throw new Error("initializeWasm() must be awaited first!");
27022 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
27023 return nativeResponseValue;
27025 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27027 export function ClosingTransaction_trust(this_arg: bigint): bigint {
27028 if(!isWasmInitialized) {
27029 throw new Error("initializeWasm() must be awaited first!");
27031 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
27032 return nativeResponseValue;
27034 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
27036 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
27037 if(!isWasmInitialized) {
27038 throw new Error("initializeWasm() must be awaited first!");
27040 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
27041 return nativeResponseValue;
27043 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27045 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
27046 if(!isWasmInitialized) {
27047 throw new Error("initializeWasm() must be awaited first!");
27049 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
27050 return nativeResponseValue;
27052 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27054 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
27055 if(!isWasmInitialized) {
27056 throw new Error("initializeWasm() must be awaited first!");
27058 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
27059 return nativeResponseValue;
27061 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27063 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
27064 if(!isWasmInitialized) {
27065 throw new Error("initializeWasm() must be awaited first!");
27067 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
27068 return nativeResponseValue;
27070 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27072 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
27073 if(!isWasmInitialized) {
27074 throw new Error("initializeWasm() must be awaited first!");
27076 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
27077 return nativeResponseValue;
27079 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
27081 export function TrustedClosingTransaction_free(this_obj: bigint): void {
27082 if(!isWasmInitialized) {
27083 throw new Error("initializeWasm() must be awaited first!");
27085 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
27086 // debug statements here
27088 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
27090 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
27091 if(!isWasmInitialized) {
27092 throw new Error("initializeWasm() must be awaited first!");
27094 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
27095 return nativeResponseValue;
27097 // 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);
27099 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
27100 if(!isWasmInitialized) {
27101 throw new Error("initializeWasm() must be awaited first!");
27103 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
27104 return nativeResponseValue;
27106 // MUST_USE_RES struct LDKSignature TrustedClosingTransaction_sign(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
27108 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
27109 if(!isWasmInitialized) {
27110 throw new Error("initializeWasm() must be awaited first!");
27112 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
27113 return nativeResponseValue;
27115 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
27117 export function CommitmentTransaction_free(this_obj: bigint): void {
27118 if(!isWasmInitialized) {
27119 throw new Error("initializeWasm() must be awaited first!");
27121 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
27122 // debug statements here
27124 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
27126 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
27127 if(!isWasmInitialized) {
27128 throw new Error("initializeWasm() must be awaited first!");
27130 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
27131 return nativeResponseValue;
27133 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
27135 export function CommitmentTransaction_clone(orig: bigint): bigint {
27136 if(!isWasmInitialized) {
27137 throw new Error("initializeWasm() must be awaited first!");
27139 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
27140 return nativeResponseValue;
27142 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
27144 export function CommitmentTransaction_write(obj: bigint): number {
27145 if(!isWasmInitialized) {
27146 throw new Error("initializeWasm() must be awaited first!");
27148 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
27149 return nativeResponseValue;
27151 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
27153 export function CommitmentTransaction_read(ser: number): bigint {
27154 if(!isWasmInitialized) {
27155 throw new Error("initializeWasm() must be awaited first!");
27157 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
27158 return nativeResponseValue;
27160 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27162 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
27163 if(!isWasmInitialized) {
27164 throw new Error("initializeWasm() must be awaited first!");
27166 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
27167 return nativeResponseValue;
27169 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27171 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
27172 if(!isWasmInitialized) {
27173 throw new Error("initializeWasm() must be awaited first!");
27175 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
27176 return nativeResponseValue;
27178 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27180 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
27181 if(!isWasmInitialized) {
27182 throw new Error("initializeWasm() must be awaited first!");
27184 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
27185 return nativeResponseValue;
27187 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27189 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
27190 if(!isWasmInitialized) {
27191 throw new Error("initializeWasm() must be awaited first!");
27193 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
27194 return nativeResponseValue;
27196 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27198 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
27199 if(!isWasmInitialized) {
27200 throw new Error("initializeWasm() must be awaited first!");
27202 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
27203 return nativeResponseValue;
27205 // 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);
27207 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
27208 if(!isWasmInitialized) {
27209 throw new Error("initializeWasm() must be awaited first!");
27211 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
27212 return nativeResponseValue;
27214 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
27216 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
27217 if(!isWasmInitialized) {
27218 throw new Error("initializeWasm() must be awaited first!");
27220 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
27221 // debug statements here
27223 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27225 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
27226 if(!isWasmInitialized) {
27227 throw new Error("initializeWasm() must be awaited first!");
27229 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
27230 return nativeResponseValue;
27232 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27234 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
27235 if(!isWasmInitialized) {
27236 throw new Error("initializeWasm() must be awaited first!");
27238 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
27239 return nativeResponseValue;
27241 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27243 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
27244 if(!isWasmInitialized) {
27245 throw new Error("initializeWasm() must be awaited first!");
27247 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
27248 return nativeResponseValue;
27250 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27252 export function TrustedCommitmentTransaction_opt_anchors(this_arg: bigint): boolean {
27253 if(!isWasmInitialized) {
27254 throw new Error("initializeWasm() must be awaited first!");
27256 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
27257 return nativeResponseValue;
27259 // MUST_USE_RES struct LDKCResult_CVec_SignatureZNoneZ TrustedCommitmentTransaction_get_htlc_sigs(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*htlc_base_key)[32], const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters);
27261 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint): bigint {
27262 if(!isWasmInitialized) {
27263 throw new Error("initializeWasm() must be awaited first!");
27265 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
27266 return nativeResponseValue;
27268 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
27270 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
27271 if(!isWasmInitialized) {
27272 throw new Error("initializeWasm() must be awaited first!");
27274 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
27275 return nativeResponseValue;
27277 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
27279 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
27280 if(!isWasmInitialized) {
27281 throw new Error("initializeWasm() must be awaited first!");
27283 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
27284 return nativeResponseValue;
27286 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
27288 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
27289 if(!isWasmInitialized) {
27290 throw new Error("initializeWasm() must be awaited first!");
27292 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
27293 return nativeResponseValue;
27295 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
27297 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
27298 if(!isWasmInitialized) {
27299 throw new Error("initializeWasm() must be awaited first!");
27301 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
27302 return nativeResponseValue;
27304 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
27306 export function InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
27307 if(!isWasmInitialized) {
27308 throw new Error("initializeWasm() must be awaited first!");
27310 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
27311 return nativeResponseValue;
27313 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
27315 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
27316 if(!isWasmInitialized) {
27317 throw new Error("initializeWasm() must be awaited first!");
27319 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
27320 return nativeResponseValue;
27322 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
27324 export function InitFeatures_clone_ptr(arg: bigint): bigint {
27325 if(!isWasmInitialized) {
27326 throw new Error("initializeWasm() must be awaited first!");
27328 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
27329 return nativeResponseValue;
27331 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
27333 export function InitFeatures_clone(orig: bigint): bigint {
27334 if(!isWasmInitialized) {
27335 throw new Error("initializeWasm() must be awaited first!");
27337 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
27338 return nativeResponseValue;
27340 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
27342 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
27343 if(!isWasmInitialized) {
27344 throw new Error("initializeWasm() must be awaited first!");
27346 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
27347 return nativeResponseValue;
27349 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
27351 export function NodeFeatures_clone(orig: bigint): bigint {
27352 if(!isWasmInitialized) {
27353 throw new Error("initializeWasm() must be awaited first!");
27355 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
27356 return nativeResponseValue;
27358 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
27360 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
27361 if(!isWasmInitialized) {
27362 throw new Error("initializeWasm() must be awaited first!");
27364 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
27365 return nativeResponseValue;
27367 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
27369 export function ChannelFeatures_clone(orig: bigint): bigint {
27370 if(!isWasmInitialized) {
27371 throw new Error("initializeWasm() must be awaited first!");
27373 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
27374 return nativeResponseValue;
27376 // uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
27378 export function InvoiceFeatures_clone_ptr(arg: bigint): bigint {
27379 if(!isWasmInitialized) {
27380 throw new Error("initializeWasm() must be awaited first!");
27382 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
27383 return nativeResponseValue;
27385 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
27387 export function InvoiceFeatures_clone(orig: bigint): bigint {
27388 if(!isWasmInitialized) {
27389 throw new Error("initializeWasm() must be awaited first!");
27391 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
27392 return nativeResponseValue;
27394 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
27396 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
27397 if(!isWasmInitialized) {
27398 throw new Error("initializeWasm() must be awaited first!");
27400 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
27401 return nativeResponseValue;
27403 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
27405 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
27406 if(!isWasmInitialized) {
27407 throw new Error("initializeWasm() must be awaited first!");
27409 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
27410 return nativeResponseValue;
27412 // void InitFeatures_free(struct LDKInitFeatures this_obj);
27414 export function InitFeatures_free(this_obj: bigint): void {
27415 if(!isWasmInitialized) {
27416 throw new Error("initializeWasm() must be awaited first!");
27418 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
27419 // debug statements here
27421 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
27423 export function NodeFeatures_free(this_obj: bigint): void {
27424 if(!isWasmInitialized) {
27425 throw new Error("initializeWasm() must be awaited first!");
27427 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
27428 // debug statements here
27430 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
27432 export function ChannelFeatures_free(this_obj: bigint): void {
27433 if(!isWasmInitialized) {
27434 throw new Error("initializeWasm() must be awaited first!");
27436 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
27437 // debug statements here
27439 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
27441 export function InvoiceFeatures_free(this_obj: bigint): void {
27442 if(!isWasmInitialized) {
27443 throw new Error("initializeWasm() must be awaited first!");
27445 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
27446 // debug statements here
27448 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
27450 export function ChannelTypeFeatures_free(this_obj: bigint): void {
27451 if(!isWasmInitialized) {
27452 throw new Error("initializeWasm() must be awaited first!");
27454 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
27455 // debug statements here
27457 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
27459 export function InitFeatures_empty(): bigint {
27460 if(!isWasmInitialized) {
27461 throw new Error("initializeWasm() must be awaited first!");
27463 const nativeResponseValue = wasm.TS_InitFeatures_empty();
27464 return nativeResponseValue;
27466 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
27468 export function InitFeatures_known(): bigint {
27469 if(!isWasmInitialized) {
27470 throw new Error("initializeWasm() must be awaited first!");
27472 const nativeResponseValue = wasm.TS_InitFeatures_known();
27473 return nativeResponseValue;
27475 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27477 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
27478 if(!isWasmInitialized) {
27479 throw new Error("initializeWasm() must be awaited first!");
27481 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
27482 return nativeResponseValue;
27484 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
27486 export function NodeFeatures_empty(): bigint {
27487 if(!isWasmInitialized) {
27488 throw new Error("initializeWasm() must be awaited first!");
27490 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
27491 return nativeResponseValue;
27493 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
27495 export function NodeFeatures_known(): bigint {
27496 if(!isWasmInitialized) {
27497 throw new Error("initializeWasm() must be awaited first!");
27499 const nativeResponseValue = wasm.TS_NodeFeatures_known();
27500 return nativeResponseValue;
27502 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27504 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
27505 if(!isWasmInitialized) {
27506 throw new Error("initializeWasm() must be awaited first!");
27508 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
27509 return nativeResponseValue;
27511 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
27513 export function ChannelFeatures_empty(): bigint {
27514 if(!isWasmInitialized) {
27515 throw new Error("initializeWasm() must be awaited first!");
27517 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
27518 return nativeResponseValue;
27520 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
27522 export function ChannelFeatures_known(): bigint {
27523 if(!isWasmInitialized) {
27524 throw new Error("initializeWasm() must be awaited first!");
27526 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
27527 return nativeResponseValue;
27529 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
27531 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
27532 if(!isWasmInitialized) {
27533 throw new Error("initializeWasm() must be awaited first!");
27535 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
27536 return nativeResponseValue;
27538 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
27540 export function InvoiceFeatures_empty(): bigint {
27541 if(!isWasmInitialized) {
27542 throw new Error("initializeWasm() must be awaited first!");
27544 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
27545 return nativeResponseValue;
27547 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
27549 export function InvoiceFeatures_known(): bigint {
27550 if(!isWasmInitialized) {
27551 throw new Error("initializeWasm() must be awaited first!");
27553 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
27554 return nativeResponseValue;
27556 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27558 export function InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
27559 if(!isWasmInitialized) {
27560 throw new Error("initializeWasm() must be awaited first!");
27562 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
27563 return nativeResponseValue;
27565 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
27567 export function ChannelTypeFeatures_empty(): bigint {
27568 if(!isWasmInitialized) {
27569 throw new Error("initializeWasm() must be awaited first!");
27571 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
27572 return nativeResponseValue;
27574 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
27576 export function ChannelTypeFeatures_known(): bigint {
27577 if(!isWasmInitialized) {
27578 throw new Error("initializeWasm() must be awaited first!");
27580 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
27581 return nativeResponseValue;
27583 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27585 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
27586 if(!isWasmInitialized) {
27587 throw new Error("initializeWasm() must be awaited first!");
27589 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
27590 return nativeResponseValue;
27592 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
27594 export function InitFeatures_write(obj: bigint): number {
27595 if(!isWasmInitialized) {
27596 throw new Error("initializeWasm() must be awaited first!");
27598 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
27599 return nativeResponseValue;
27601 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
27603 export function InitFeatures_read(ser: number): bigint {
27604 if(!isWasmInitialized) {
27605 throw new Error("initializeWasm() must be awaited first!");
27607 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
27608 return nativeResponseValue;
27610 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
27612 export function ChannelFeatures_write(obj: bigint): number {
27613 if(!isWasmInitialized) {
27614 throw new Error("initializeWasm() must be awaited first!");
27616 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
27617 return nativeResponseValue;
27619 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
27621 export function ChannelFeatures_read(ser: number): bigint {
27622 if(!isWasmInitialized) {
27623 throw new Error("initializeWasm() must be awaited first!");
27625 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
27626 return nativeResponseValue;
27628 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
27630 export function NodeFeatures_write(obj: bigint): number {
27631 if(!isWasmInitialized) {
27632 throw new Error("initializeWasm() must be awaited first!");
27634 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
27635 return nativeResponseValue;
27637 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
27639 export function NodeFeatures_read(ser: number): bigint {
27640 if(!isWasmInitialized) {
27641 throw new Error("initializeWasm() must be awaited first!");
27643 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
27644 return nativeResponseValue;
27646 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
27648 export function InvoiceFeatures_write(obj: bigint): number {
27649 if(!isWasmInitialized) {
27650 throw new Error("initializeWasm() must be awaited first!");
27652 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
27653 return nativeResponseValue;
27655 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
27657 export function InvoiceFeatures_read(ser: number): bigint {
27658 if(!isWasmInitialized) {
27659 throw new Error("initializeWasm() must be awaited first!");
27661 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
27662 return nativeResponseValue;
27664 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
27666 export function ChannelTypeFeatures_write(obj: bigint): number {
27667 if(!isWasmInitialized) {
27668 throw new Error("initializeWasm() must be awaited first!");
27670 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
27671 return nativeResponseValue;
27673 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
27675 export function ChannelTypeFeatures_read(ser: number): bigint {
27676 if(!isWasmInitialized) {
27677 throw new Error("initializeWasm() must be awaited first!");
27679 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
27680 return nativeResponseValue;
27682 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27684 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
27685 if(!isWasmInitialized) {
27686 throw new Error("initializeWasm() must be awaited first!");
27688 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
27689 // debug statements here
27691 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27693 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
27694 if(!isWasmInitialized) {
27695 throw new Error("initializeWasm() must be awaited first!");
27697 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
27698 // debug statements here
27700 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27702 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
27703 if(!isWasmInitialized) {
27704 throw new Error("initializeWasm() must be awaited first!");
27706 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
27707 return nativeResponseValue;
27709 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27711 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
27712 if(!isWasmInitialized) {
27713 throw new Error("initializeWasm() must be awaited first!");
27715 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
27716 // debug statements here
27718 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27720 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
27721 if(!isWasmInitialized) {
27722 throw new Error("initializeWasm() must be awaited first!");
27724 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
27725 // debug statements here
27727 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27729 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
27730 if(!isWasmInitialized) {
27731 throw new Error("initializeWasm() must be awaited first!");
27733 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
27734 return nativeResponseValue;
27736 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27738 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
27739 if(!isWasmInitialized) {
27740 throw new Error("initializeWasm() must be awaited first!");
27742 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
27743 return nativeResponseValue;
27745 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27747 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
27748 if(!isWasmInitialized) {
27749 throw new Error("initializeWasm() must be awaited first!");
27751 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
27752 return nativeResponseValue;
27754 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27756 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
27757 if(!isWasmInitialized) {
27758 throw new Error("initializeWasm() must be awaited first!");
27760 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
27761 // debug statements here
27763 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27765 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
27766 if(!isWasmInitialized) {
27767 throw new Error("initializeWasm() must be awaited first!");
27769 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
27770 // debug statements here
27772 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27774 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
27775 if(!isWasmInitialized) {
27776 throw new Error("initializeWasm() must be awaited first!");
27778 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
27779 return nativeResponseValue;
27781 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27783 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
27784 if(!isWasmInitialized) {
27785 throw new Error("initializeWasm() must be awaited first!");
27787 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
27788 // debug statements here
27790 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27792 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
27793 if(!isWasmInitialized) {
27794 throw new Error("initializeWasm() must be awaited first!");
27796 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
27797 // debug statements here
27799 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27801 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
27802 if(!isWasmInitialized) {
27803 throw new Error("initializeWasm() must be awaited first!");
27805 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
27806 return nativeResponseValue;
27808 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27810 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
27811 if(!isWasmInitialized) {
27812 throw new Error("initializeWasm() must be awaited first!");
27814 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
27815 // debug statements here
27817 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27819 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
27820 if(!isWasmInitialized) {
27821 throw new Error("initializeWasm() must be awaited first!");
27823 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
27824 // debug statements here
27826 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27828 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
27829 if(!isWasmInitialized) {
27830 throw new Error("initializeWasm() must be awaited first!");
27832 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
27833 return nativeResponseValue;
27835 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27837 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
27838 if(!isWasmInitialized) {
27839 throw new Error("initializeWasm() must be awaited first!");
27841 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
27842 return nativeResponseValue;
27844 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27846 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
27847 if(!isWasmInitialized) {
27848 throw new Error("initializeWasm() must be awaited first!");
27850 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
27851 return nativeResponseValue;
27853 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27855 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
27856 if(!isWasmInitialized) {
27857 throw new Error("initializeWasm() must be awaited first!");
27859 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
27860 // debug statements here
27862 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27864 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
27865 if(!isWasmInitialized) {
27866 throw new Error("initializeWasm() must be awaited first!");
27868 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
27869 // debug statements here
27871 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27873 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
27874 if(!isWasmInitialized) {
27875 throw new Error("initializeWasm() must be awaited first!");
27877 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
27878 return nativeResponseValue;
27880 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27882 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
27883 if(!isWasmInitialized) {
27884 throw new Error("initializeWasm() must be awaited first!");
27886 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27887 // debug statements here
27889 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27891 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
27892 if(!isWasmInitialized) {
27893 throw new Error("initializeWasm() must be awaited first!");
27895 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27896 // debug statements here
27898 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27900 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
27901 if(!isWasmInitialized) {
27902 throw new Error("initializeWasm() must be awaited first!");
27904 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27905 return nativeResponseValue;
27907 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27909 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
27910 if(!isWasmInitialized) {
27911 throw new Error("initializeWasm() must be awaited first!");
27913 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27914 return nativeResponseValue;
27916 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27918 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
27919 if(!isWasmInitialized) {
27920 throw new Error("initializeWasm() must be awaited first!");
27922 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27923 return nativeResponseValue;
27925 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27927 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
27928 if(!isWasmInitialized) {
27929 throw new Error("initializeWasm() must be awaited first!");
27931 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27932 // debug statements here
27934 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27936 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
27937 if(!isWasmInitialized) {
27938 throw new Error("initializeWasm() must be awaited first!");
27940 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27941 // debug statements here
27943 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27945 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
27946 if(!isWasmInitialized) {
27947 throw new Error("initializeWasm() must be awaited first!");
27949 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27950 return nativeResponseValue;
27952 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27954 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
27955 if(!isWasmInitialized) {
27956 throw new Error("initializeWasm() must be awaited first!");
27958 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27959 // debug statements here
27961 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27963 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
27964 if(!isWasmInitialized) {
27965 throw new Error("initializeWasm() must be awaited first!");
27967 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27968 // debug statements here
27970 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27972 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
27973 if(!isWasmInitialized) {
27974 throw new Error("initializeWasm() must be awaited first!");
27976 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27977 return nativeResponseValue;
27979 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27981 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
27982 if(!isWasmInitialized) {
27983 throw new Error("initializeWasm() must be awaited first!");
27985 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27986 // debug statements here
27988 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27990 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
27991 if(!isWasmInitialized) {
27992 throw new Error("initializeWasm() must be awaited first!");
27994 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27995 // debug statements here
27997 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27999 export function InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
28000 if(!isWasmInitialized) {
28001 throw new Error("initializeWasm() must be awaited first!");
28003 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
28004 return nativeResponseValue;
28006 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28008 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
28009 if(!isWasmInitialized) {
28010 throw new Error("initializeWasm() must be awaited first!");
28012 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
28013 return nativeResponseValue;
28015 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28017 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
28018 if(!isWasmInitialized) {
28019 throw new Error("initializeWasm() must be awaited first!");
28021 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
28022 return nativeResponseValue;
28024 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28026 export function InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
28027 if(!isWasmInitialized) {
28028 throw new Error("initializeWasm() must be awaited first!");
28030 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
28031 return nativeResponseValue;
28033 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28035 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
28036 if(!isWasmInitialized) {
28037 throw new Error("initializeWasm() must be awaited first!");
28039 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
28040 // debug statements here
28042 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28044 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
28045 if(!isWasmInitialized) {
28046 throw new Error("initializeWasm() must be awaited first!");
28048 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
28049 // debug statements here
28051 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28053 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
28054 if(!isWasmInitialized) {
28055 throw new Error("initializeWasm() must be awaited first!");
28057 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
28058 return nativeResponseValue;
28060 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28062 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
28063 if(!isWasmInitialized) {
28064 throw new Error("initializeWasm() must be awaited first!");
28066 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
28067 // debug statements here
28069 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28071 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
28072 if(!isWasmInitialized) {
28073 throw new Error("initializeWasm() must be awaited first!");
28075 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
28076 // debug statements here
28078 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28080 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
28081 if(!isWasmInitialized) {
28082 throw new Error("initializeWasm() must be awaited first!");
28084 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
28085 return nativeResponseValue;
28087 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28089 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
28090 if(!isWasmInitialized) {
28091 throw new Error("initializeWasm() must be awaited first!");
28093 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
28094 // debug statements here
28096 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28098 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
28099 if(!isWasmInitialized) {
28100 throw new Error("initializeWasm() must be awaited first!");
28102 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
28103 // debug statements here
28105 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28107 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
28108 if(!isWasmInitialized) {
28109 throw new Error("initializeWasm() must be awaited first!");
28111 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
28112 return nativeResponseValue;
28114 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28116 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
28117 if(!isWasmInitialized) {
28118 throw new Error("initializeWasm() must be awaited first!");
28120 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
28121 return nativeResponseValue;
28123 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28125 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
28126 if(!isWasmInitialized) {
28127 throw new Error("initializeWasm() must be awaited first!");
28129 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
28130 return nativeResponseValue;
28132 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28134 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
28135 if(!isWasmInitialized) {
28136 throw new Error("initializeWasm() must be awaited first!");
28138 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
28139 return nativeResponseValue;
28141 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28143 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
28144 if(!isWasmInitialized) {
28145 throw new Error("initializeWasm() must be awaited first!");
28147 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
28148 // debug statements here
28150 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28152 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
28153 if(!isWasmInitialized) {
28154 throw new Error("initializeWasm() must be awaited first!");
28156 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
28157 // debug statements here
28159 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28161 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
28162 if(!isWasmInitialized) {
28163 throw new Error("initializeWasm() must be awaited first!");
28165 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
28166 return nativeResponseValue;
28168 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28170 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
28171 if(!isWasmInitialized) {
28172 throw new Error("initializeWasm() must be awaited first!");
28174 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
28175 // debug statements here
28177 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28179 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
28180 if(!isWasmInitialized) {
28181 throw new Error("initializeWasm() must be awaited first!");
28183 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
28184 // debug statements here
28186 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28188 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
28189 if(!isWasmInitialized) {
28190 throw new Error("initializeWasm() must be awaited first!");
28192 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
28193 return nativeResponseValue;
28195 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28197 export function InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
28198 if(!isWasmInitialized) {
28199 throw new Error("initializeWasm() must be awaited first!");
28201 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
28202 // debug statements here
28204 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28206 export function InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
28207 if(!isWasmInitialized) {
28208 throw new Error("initializeWasm() must be awaited first!");
28210 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
28211 // debug statements here
28213 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28215 export function InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
28216 if(!isWasmInitialized) {
28217 throw new Error("initializeWasm() must be awaited first!");
28219 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
28220 return nativeResponseValue;
28222 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28224 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
28225 if(!isWasmInitialized) {
28226 throw new Error("initializeWasm() must be awaited first!");
28228 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
28229 return nativeResponseValue;
28231 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28233 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
28234 if(!isWasmInitialized) {
28235 throw new Error("initializeWasm() must be awaited first!");
28237 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
28238 return nativeResponseValue;
28240 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28242 export function InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
28243 if(!isWasmInitialized) {
28244 throw new Error("initializeWasm() must be awaited first!");
28246 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
28247 return nativeResponseValue;
28249 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28251 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
28252 if(!isWasmInitialized) {
28253 throw new Error("initializeWasm() must be awaited first!");
28255 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
28256 // debug statements here
28258 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28260 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
28261 if(!isWasmInitialized) {
28262 throw new Error("initializeWasm() must be awaited first!");
28264 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
28265 // debug statements here
28267 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28269 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
28270 if(!isWasmInitialized) {
28271 throw new Error("initializeWasm() must be awaited first!");
28273 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
28274 return nativeResponseValue;
28276 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28278 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
28279 if(!isWasmInitialized) {
28280 throw new Error("initializeWasm() must be awaited first!");
28282 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
28283 // debug statements here
28285 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28287 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
28288 if(!isWasmInitialized) {
28289 throw new Error("initializeWasm() must be awaited first!");
28291 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
28292 // debug statements here
28294 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28296 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
28297 if(!isWasmInitialized) {
28298 throw new Error("initializeWasm() must be awaited first!");
28300 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
28301 return nativeResponseValue;
28303 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28305 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
28306 if(!isWasmInitialized) {
28307 throw new Error("initializeWasm() must be awaited first!");
28309 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
28310 // debug statements here
28312 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28314 export function InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
28315 if(!isWasmInitialized) {
28316 throw new Error("initializeWasm() must be awaited first!");
28318 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
28319 // debug statements here
28321 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28323 export function InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
28324 if(!isWasmInitialized) {
28325 throw new Error("initializeWasm() must be awaited first!");
28327 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
28328 return nativeResponseValue;
28330 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28332 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
28333 if(!isWasmInitialized) {
28334 throw new Error("initializeWasm() must be awaited first!");
28336 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
28337 return nativeResponseValue;
28339 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28341 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
28342 if(!isWasmInitialized) {
28343 throw new Error("initializeWasm() must be awaited first!");
28345 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
28346 return nativeResponseValue;
28348 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28350 export function InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
28351 if(!isWasmInitialized) {
28352 throw new Error("initializeWasm() must be awaited first!");
28354 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
28355 return nativeResponseValue;
28357 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28359 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
28360 if(!isWasmInitialized) {
28361 throw new Error("initializeWasm() must be awaited first!");
28363 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
28364 // debug statements here
28366 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28368 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
28369 if(!isWasmInitialized) {
28370 throw new Error("initializeWasm() must be awaited first!");
28372 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
28373 // debug statements here
28375 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28377 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
28378 if(!isWasmInitialized) {
28379 throw new Error("initializeWasm() must be awaited first!");
28381 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
28382 return nativeResponseValue;
28384 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28386 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
28387 if(!isWasmInitialized) {
28388 throw new Error("initializeWasm() must be awaited first!");
28390 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
28391 // debug statements here
28393 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28395 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
28396 if(!isWasmInitialized) {
28397 throw new Error("initializeWasm() must be awaited first!");
28399 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
28400 // debug statements here
28402 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28404 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
28405 if(!isWasmInitialized) {
28406 throw new Error("initializeWasm() must be awaited first!");
28408 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
28409 return nativeResponseValue;
28411 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28413 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
28414 if(!isWasmInitialized) {
28415 throw new Error("initializeWasm() must be awaited first!");
28417 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
28418 return nativeResponseValue;
28420 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28422 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
28423 if(!isWasmInitialized) {
28424 throw new Error("initializeWasm() must be awaited first!");
28426 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
28427 return nativeResponseValue;
28429 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28431 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
28432 if(!isWasmInitialized) {
28433 throw new Error("initializeWasm() must be awaited first!");
28435 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
28436 // debug statements here
28438 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28440 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
28441 if(!isWasmInitialized) {
28442 throw new Error("initializeWasm() must be awaited first!");
28444 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
28445 // debug statements here
28447 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28449 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
28450 if(!isWasmInitialized) {
28451 throw new Error("initializeWasm() must be awaited first!");
28453 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
28454 return nativeResponseValue;
28456 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28458 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
28459 if(!isWasmInitialized) {
28460 throw new Error("initializeWasm() must be awaited first!");
28462 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
28463 // debug statements here
28465 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28467 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
28468 if(!isWasmInitialized) {
28469 throw new Error("initializeWasm() must be awaited first!");
28471 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
28472 // debug statements here
28474 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28476 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
28477 if(!isWasmInitialized) {
28478 throw new Error("initializeWasm() must be awaited first!");
28480 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
28481 return nativeResponseValue;
28483 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28485 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
28486 if(!isWasmInitialized) {
28487 throw new Error("initializeWasm() must be awaited first!");
28489 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
28490 return nativeResponseValue;
28492 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28494 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
28495 if(!isWasmInitialized) {
28496 throw new Error("initializeWasm() must be awaited first!");
28498 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
28499 return nativeResponseValue;
28501 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28503 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
28504 if(!isWasmInitialized) {
28505 throw new Error("initializeWasm() must be awaited first!");
28507 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
28508 // debug statements here
28510 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28512 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
28513 if(!isWasmInitialized) {
28514 throw new Error("initializeWasm() must be awaited first!");
28516 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
28517 // debug statements here
28519 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28521 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
28522 if(!isWasmInitialized) {
28523 throw new Error("initializeWasm() must be awaited first!");
28525 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
28526 return nativeResponseValue;
28528 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28530 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
28531 if(!isWasmInitialized) {
28532 throw new Error("initializeWasm() must be awaited first!");
28534 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
28535 // debug statements here
28537 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28539 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
28540 if(!isWasmInitialized) {
28541 throw new Error("initializeWasm() must be awaited first!");
28543 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
28544 // debug statements here
28546 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28548 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
28549 if(!isWasmInitialized) {
28550 throw new Error("initializeWasm() must be awaited first!");
28552 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
28553 return nativeResponseValue;
28555 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28557 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
28558 if(!isWasmInitialized) {
28559 throw new Error("initializeWasm() must be awaited first!");
28561 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
28562 return nativeResponseValue;
28564 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28566 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
28567 if(!isWasmInitialized) {
28568 throw new Error("initializeWasm() must be awaited first!");
28570 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
28571 return nativeResponseValue;
28573 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28575 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
28576 if(!isWasmInitialized) {
28577 throw new Error("initializeWasm() must be awaited first!");
28579 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
28580 // debug statements here
28582 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28584 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
28585 if(!isWasmInitialized) {
28586 throw new Error("initializeWasm() must be awaited first!");
28588 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
28589 // debug statements here
28591 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28593 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
28594 if(!isWasmInitialized) {
28595 throw new Error("initializeWasm() must be awaited first!");
28597 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
28598 return nativeResponseValue;
28600 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28602 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
28603 if(!isWasmInitialized) {
28604 throw new Error("initializeWasm() must be awaited first!");
28606 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
28607 // debug statements here
28609 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28611 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
28612 if(!isWasmInitialized) {
28613 throw new Error("initializeWasm() must be awaited first!");
28615 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
28616 // debug statements here
28618 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28620 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
28621 if(!isWasmInitialized) {
28622 throw new Error("initializeWasm() must be awaited first!");
28624 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
28625 return nativeResponseValue;
28627 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28629 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
28630 if(!isWasmInitialized) {
28631 throw new Error("initializeWasm() must be awaited first!");
28633 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
28634 // debug statements here
28636 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28638 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
28639 if(!isWasmInitialized) {
28640 throw new Error("initializeWasm() must be awaited first!");
28642 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
28643 // debug statements here
28645 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28647 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
28648 if(!isWasmInitialized) {
28649 throw new Error("initializeWasm() must be awaited first!");
28651 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
28652 return nativeResponseValue;
28654 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28656 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
28657 if(!isWasmInitialized) {
28658 throw new Error("initializeWasm() must be awaited first!");
28660 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
28661 return nativeResponseValue;
28663 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28665 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
28666 if(!isWasmInitialized) {
28667 throw new Error("initializeWasm() must be awaited first!");
28669 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
28670 return nativeResponseValue;
28672 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28674 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
28675 if(!isWasmInitialized) {
28676 throw new Error("initializeWasm() must be awaited first!");
28678 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
28679 return nativeResponseValue;
28681 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28683 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
28684 if(!isWasmInitialized) {
28685 throw new Error("initializeWasm() must be awaited first!");
28687 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
28688 // debug statements here
28690 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28692 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
28693 if(!isWasmInitialized) {
28694 throw new Error("initializeWasm() must be awaited first!");
28696 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
28697 // debug statements here
28699 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28701 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
28702 if(!isWasmInitialized) {
28703 throw new Error("initializeWasm() must be awaited first!");
28705 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
28706 return nativeResponseValue;
28708 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28710 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
28711 if(!isWasmInitialized) {
28712 throw new Error("initializeWasm() must be awaited first!");
28714 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
28715 // debug statements here
28717 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28719 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
28720 if(!isWasmInitialized) {
28721 throw new Error("initializeWasm() must be awaited first!");
28723 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
28724 // debug statements here
28726 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28728 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
28729 if(!isWasmInitialized) {
28730 throw new Error("initializeWasm() must be awaited first!");
28732 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
28733 return nativeResponseValue;
28735 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28737 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
28738 if(!isWasmInitialized) {
28739 throw new Error("initializeWasm() must be awaited first!");
28741 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
28742 // debug statements here
28744 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28746 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
28747 if(!isWasmInitialized) {
28748 throw new Error("initializeWasm() must be awaited first!");
28750 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
28751 // debug statements here
28753 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28755 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
28756 if(!isWasmInitialized) {
28757 throw new Error("initializeWasm() must be awaited first!");
28759 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
28760 return nativeResponseValue;
28762 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28764 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
28765 if(!isWasmInitialized) {
28766 throw new Error("initializeWasm() must be awaited first!");
28768 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
28769 return nativeResponseValue;
28771 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28773 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
28774 if(!isWasmInitialized) {
28775 throw new Error("initializeWasm() must be awaited first!");
28777 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
28778 return nativeResponseValue;
28780 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28782 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
28783 if(!isWasmInitialized) {
28784 throw new Error("initializeWasm() must be awaited first!");
28786 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
28787 return nativeResponseValue;
28789 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28791 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
28792 if(!isWasmInitialized) {
28793 throw new Error("initializeWasm() must be awaited first!");
28795 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
28796 // debug statements here
28798 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28800 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
28801 if(!isWasmInitialized) {
28802 throw new Error("initializeWasm() must be awaited first!");
28804 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
28805 // debug statements here
28807 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28809 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
28810 if(!isWasmInitialized) {
28811 throw new Error("initializeWasm() must be awaited first!");
28813 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
28814 return nativeResponseValue;
28816 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28818 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
28819 if(!isWasmInitialized) {
28820 throw new Error("initializeWasm() must be awaited first!");
28822 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
28823 return nativeResponseValue;
28825 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
28827 export function ShutdownScript_free(this_obj: bigint): void {
28828 if(!isWasmInitialized) {
28829 throw new Error("initializeWasm() must be awaited first!");
28831 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
28832 // debug statements here
28834 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
28836 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
28837 if(!isWasmInitialized) {
28838 throw new Error("initializeWasm() must be awaited first!");
28840 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
28841 return nativeResponseValue;
28843 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
28845 export function ShutdownScript_clone(orig: bigint): bigint {
28846 if(!isWasmInitialized) {
28847 throw new Error("initializeWasm() must be awaited first!");
28849 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
28850 return nativeResponseValue;
28852 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
28854 export function InvalidShutdownScript_free(this_obj: bigint): void {
28855 if(!isWasmInitialized) {
28856 throw new Error("initializeWasm() must be awaited first!");
28858 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
28859 // debug statements here
28861 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
28863 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
28864 if(!isWasmInitialized) {
28865 throw new Error("initializeWasm() must be awaited first!");
28867 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
28868 return nativeResponseValue;
28870 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
28872 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
28873 if(!isWasmInitialized) {
28874 throw new Error("initializeWasm() must be awaited first!");
28876 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
28877 // debug statements here
28879 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28881 export function InvalidShutdownScript_new(script_arg: number): bigint {
28882 if(!isWasmInitialized) {
28883 throw new Error("initializeWasm() must be awaited first!");
28885 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28886 return nativeResponseValue;
28888 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28890 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
28891 if(!isWasmInitialized) {
28892 throw new Error("initializeWasm() must be awaited first!");
28894 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28895 return nativeResponseValue;
28897 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28899 export function InvalidShutdownScript_clone(orig: bigint): bigint {
28900 if(!isWasmInitialized) {
28901 throw new Error("initializeWasm() must be awaited first!");
28903 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28904 return nativeResponseValue;
28906 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28908 export function ShutdownScript_write(obj: bigint): number {
28909 if(!isWasmInitialized) {
28910 throw new Error("initializeWasm() must be awaited first!");
28912 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28913 return nativeResponseValue;
28915 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28917 export function ShutdownScript_read(ser: number): bigint {
28918 if(!isWasmInitialized) {
28919 throw new Error("initializeWasm() must be awaited first!");
28921 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28922 return nativeResponseValue;
28924 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28926 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
28927 if(!isWasmInitialized) {
28928 throw new Error("initializeWasm() must be awaited first!");
28930 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28931 return nativeResponseValue;
28933 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28935 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
28936 if(!isWasmInitialized) {
28937 throw new Error("initializeWasm() must be awaited first!");
28939 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28940 return nativeResponseValue;
28942 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28944 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
28945 if(!isWasmInitialized) {
28946 throw new Error("initializeWasm() must be awaited first!");
28948 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28949 return nativeResponseValue;
28951 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28953 export function ShutdownScript_into_inner(this_arg: bigint): number {
28954 if(!isWasmInitialized) {
28955 throw new Error("initializeWasm() must be awaited first!");
28957 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28958 return nativeResponseValue;
28960 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28962 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
28963 if(!isWasmInitialized) {
28964 throw new Error("initializeWasm() must be awaited first!");
28966 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28967 return nativeResponseValue;
28969 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28971 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
28972 if(!isWasmInitialized) {
28973 throw new Error("initializeWasm() must be awaited first!");
28975 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28976 return nativeResponseValue;
28978 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28980 export function CustomMessageReader_free(this_ptr: bigint): void {
28981 if(!isWasmInitialized) {
28982 throw new Error("initializeWasm() must be awaited first!");
28984 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28985 // debug statements here
28987 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28989 export function Type_clone_ptr(arg: bigint): bigint {
28990 if(!isWasmInitialized) {
28991 throw new Error("initializeWasm() must be awaited first!");
28993 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28994 return nativeResponseValue;
28996 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28998 export function Type_clone(orig: bigint): bigint {
28999 if(!isWasmInitialized) {
29000 throw new Error("initializeWasm() must be awaited first!");
29002 const nativeResponseValue = wasm.TS_Type_clone(orig);
29003 return nativeResponseValue;
29005 // void Type_free(struct LDKType this_ptr);
29007 export function Type_free(this_ptr: bigint): void {
29008 if(!isWasmInitialized) {
29009 throw new Error("initializeWasm() must be awaited first!");
29011 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
29012 // debug statements here
29014 // void NodeId_free(struct LDKNodeId this_obj);
29016 export function NodeId_free(this_obj: bigint): void {
29017 if(!isWasmInitialized) {
29018 throw new Error("initializeWasm() must be awaited first!");
29020 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
29021 // debug statements here
29023 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
29025 export function NodeId_clone_ptr(arg: bigint): bigint {
29026 if(!isWasmInitialized) {
29027 throw new Error("initializeWasm() must be awaited first!");
29029 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
29030 return nativeResponseValue;
29032 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
29034 export function NodeId_clone(orig: bigint): bigint {
29035 if(!isWasmInitialized) {
29036 throw new Error("initializeWasm() must be awaited first!");
29038 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
29039 return nativeResponseValue;
29041 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
29043 export function NodeId_from_pubkey(pubkey: number): bigint {
29044 if(!isWasmInitialized) {
29045 throw new Error("initializeWasm() must be awaited first!");
29047 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
29048 return nativeResponseValue;
29050 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
29052 export function NodeId_as_slice(this_arg: bigint): number {
29053 if(!isWasmInitialized) {
29054 throw new Error("initializeWasm() must be awaited first!");
29056 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
29057 return nativeResponseValue;
29059 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
29061 export function NodeId_hash(o: bigint): bigint {
29062 if(!isWasmInitialized) {
29063 throw new Error("initializeWasm() must be awaited first!");
29065 const nativeResponseValue = wasm.TS_NodeId_hash(o);
29066 return nativeResponseValue;
29068 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
29070 export function NodeId_write(obj: bigint): number {
29071 if(!isWasmInitialized) {
29072 throw new Error("initializeWasm() must be awaited first!");
29074 const nativeResponseValue = wasm.TS_NodeId_write(obj);
29075 return nativeResponseValue;
29077 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
29079 export function NodeId_read(ser: number): bigint {
29080 if(!isWasmInitialized) {
29081 throw new Error("initializeWasm() must be awaited first!");
29083 const nativeResponseValue = wasm.TS_NodeId_read(ser);
29084 return nativeResponseValue;
29086 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
29088 export function NetworkGraph_free(this_obj: bigint): void {
29089 if(!isWasmInitialized) {
29090 throw new Error("initializeWasm() must be awaited first!");
29092 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
29093 // debug statements here
29095 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
29097 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
29098 if(!isWasmInitialized) {
29099 throw new Error("initializeWasm() must be awaited first!");
29101 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
29102 // debug statements here
29104 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
29106 export function NetworkUpdate_free(this_ptr: bigint): void {
29107 if(!isWasmInitialized) {
29108 throw new Error("initializeWasm() must be awaited first!");
29110 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
29111 // debug statements here
29113 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
29115 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
29116 if(!isWasmInitialized) {
29117 throw new Error("initializeWasm() must be awaited first!");
29119 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
29120 return nativeResponseValue;
29122 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
29124 export function NetworkUpdate_clone(orig: bigint): bigint {
29125 if(!isWasmInitialized) {
29126 throw new Error("initializeWasm() must be awaited first!");
29128 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
29129 return nativeResponseValue;
29131 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
29133 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
29134 if(!isWasmInitialized) {
29135 throw new Error("initializeWasm() must be awaited first!");
29137 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
29138 return nativeResponseValue;
29140 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
29142 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
29143 if(!isWasmInitialized) {
29144 throw new Error("initializeWasm() must be awaited first!");
29146 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
29147 return nativeResponseValue;
29149 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
29151 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
29152 if(!isWasmInitialized) {
29153 throw new Error("initializeWasm() must be awaited first!");
29155 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
29156 return nativeResponseValue;
29158 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
29160 export function NetworkUpdate_write(obj: bigint): number {
29161 if(!isWasmInitialized) {
29162 throw new Error("initializeWasm() must be awaited first!");
29164 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
29165 return nativeResponseValue;
29167 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
29169 export function NetworkUpdate_read(ser: number): bigint {
29170 if(!isWasmInitialized) {
29171 throw new Error("initializeWasm() must be awaited first!");
29173 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
29174 return nativeResponseValue;
29176 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
29178 export function P2PGossipSync_free(this_obj: bigint): void {
29179 if(!isWasmInitialized) {
29180 throw new Error("initializeWasm() must be awaited first!");
29182 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
29183 // debug statements here
29185 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
29187 export function P2PGossipSync_new(network_graph: bigint, chain_access: bigint, logger: bigint): bigint {
29188 if(!isWasmInitialized) {
29189 throw new Error("initializeWasm() must be awaited first!");
29191 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
29192 return nativeResponseValue;
29194 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
29196 export function P2PGossipSync_add_chain_access(this_arg: bigint, chain_access: bigint): void {
29197 if(!isWasmInitialized) {
29198 throw new Error("initializeWasm() must be awaited first!");
29200 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
29201 // debug statements here
29203 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29205 export function NetworkGraph_as_EventHandler(this_arg: bigint): bigint {
29206 if(!isWasmInitialized) {
29207 throw new Error("initializeWasm() must be awaited first!");
29209 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
29210 return nativeResponseValue;
29212 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
29214 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
29215 if(!isWasmInitialized) {
29216 throw new Error("initializeWasm() must be awaited first!");
29218 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
29219 return nativeResponseValue;
29221 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
29223 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
29224 if(!isWasmInitialized) {
29225 throw new Error("initializeWasm() must be awaited first!");
29227 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
29228 return nativeResponseValue;
29230 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
29232 export function ChannelUpdateInfo_free(this_obj: bigint): void {
29233 if(!isWasmInitialized) {
29234 throw new Error("initializeWasm() must be awaited first!");
29236 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
29237 // debug statements here
29239 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29241 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
29242 if(!isWasmInitialized) {
29243 throw new Error("initializeWasm() must be awaited first!");
29245 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
29246 return nativeResponseValue;
29248 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
29250 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
29251 if(!isWasmInitialized) {
29252 throw new Error("initializeWasm() must be awaited first!");
29254 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
29255 // debug statements here
29257 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29259 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
29260 if(!isWasmInitialized) {
29261 throw new Error("initializeWasm() must be awaited first!");
29263 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
29264 return nativeResponseValue;
29266 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
29268 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
29269 if(!isWasmInitialized) {
29270 throw new Error("initializeWasm() must be awaited first!");
29272 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
29273 // debug statements here
29275 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29277 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
29278 if(!isWasmInitialized) {
29279 throw new Error("initializeWasm() must be awaited first!");
29281 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
29282 return nativeResponseValue;
29284 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
29286 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
29287 if(!isWasmInitialized) {
29288 throw new Error("initializeWasm() must be awaited first!");
29290 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
29291 // debug statements here
29293 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29295 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
29296 if(!isWasmInitialized) {
29297 throw new Error("initializeWasm() must be awaited first!");
29299 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
29300 return nativeResponseValue;
29302 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
29304 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
29305 if(!isWasmInitialized) {
29306 throw new Error("initializeWasm() must be awaited first!");
29308 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
29309 // debug statements here
29311 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29313 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
29314 if(!isWasmInitialized) {
29315 throw new Error("initializeWasm() must be awaited first!");
29317 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
29318 return nativeResponseValue;
29320 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
29322 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
29323 if(!isWasmInitialized) {
29324 throw new Error("initializeWasm() must be awaited first!");
29326 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
29327 // debug statements here
29329 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29331 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
29332 if(!isWasmInitialized) {
29333 throw new Error("initializeWasm() must be awaited first!");
29335 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
29336 return nativeResponseValue;
29338 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29340 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
29341 if(!isWasmInitialized) {
29342 throw new Error("initializeWasm() must be awaited first!");
29344 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
29345 // debug statements here
29347 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29349 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
29350 if(!isWasmInitialized) {
29351 throw new Error("initializeWasm() must be awaited first!");
29353 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
29354 return nativeResponseValue;
29356 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
29358 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
29359 if(!isWasmInitialized) {
29360 throw new Error("initializeWasm() must be awaited first!");
29362 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
29363 // debug statements here
29365 // 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);
29367 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 {
29368 if(!isWasmInitialized) {
29369 throw new Error("initializeWasm() must be awaited first!");
29371 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);
29372 return nativeResponseValue;
29374 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
29376 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
29377 if(!isWasmInitialized) {
29378 throw new Error("initializeWasm() must be awaited first!");
29380 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
29381 return nativeResponseValue;
29383 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
29385 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
29386 if(!isWasmInitialized) {
29387 throw new Error("initializeWasm() must be awaited first!");
29389 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
29390 return nativeResponseValue;
29392 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
29394 export function ChannelUpdateInfo_write(obj: bigint): number {
29395 if(!isWasmInitialized) {
29396 throw new Error("initializeWasm() must be awaited first!");
29398 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
29399 return nativeResponseValue;
29401 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
29403 export function ChannelUpdateInfo_read(ser: number): bigint {
29404 if(!isWasmInitialized) {
29405 throw new Error("initializeWasm() must be awaited first!");
29407 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
29408 return nativeResponseValue;
29410 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
29412 export function ChannelInfo_free(this_obj: bigint): void {
29413 if(!isWasmInitialized) {
29414 throw new Error("initializeWasm() must be awaited first!");
29416 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
29417 // debug statements here
29419 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29421 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
29422 if(!isWasmInitialized) {
29423 throw new Error("initializeWasm() must be awaited first!");
29425 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
29426 return nativeResponseValue;
29428 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29430 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
29431 if(!isWasmInitialized) {
29432 throw new Error("initializeWasm() must be awaited first!");
29434 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
29435 // debug statements here
29437 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29439 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
29440 if(!isWasmInitialized) {
29441 throw new Error("initializeWasm() must be awaited first!");
29443 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
29444 return nativeResponseValue;
29446 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
29448 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
29449 if(!isWasmInitialized) {
29450 throw new Error("initializeWasm() must be awaited first!");
29452 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
29453 // debug statements here
29455 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29457 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
29458 if(!isWasmInitialized) {
29459 throw new Error("initializeWasm() must be awaited first!");
29461 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
29462 return nativeResponseValue;
29464 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
29466 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
29467 if(!isWasmInitialized) {
29468 throw new Error("initializeWasm() must be awaited first!");
29470 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
29471 // debug statements here
29473 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29475 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
29476 if(!isWasmInitialized) {
29477 throw new Error("initializeWasm() must be awaited first!");
29479 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
29480 return nativeResponseValue;
29482 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
29484 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
29485 if(!isWasmInitialized) {
29486 throw new Error("initializeWasm() must be awaited first!");
29488 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
29489 // debug statements here
29491 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29493 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
29494 if(!isWasmInitialized) {
29495 throw new Error("initializeWasm() must be awaited first!");
29497 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
29498 return nativeResponseValue;
29500 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
29502 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
29503 if(!isWasmInitialized) {
29504 throw new Error("initializeWasm() must be awaited first!");
29506 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
29507 // debug statements here
29509 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29511 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
29512 if(!isWasmInitialized) {
29513 throw new Error("initializeWasm() must be awaited first!");
29515 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
29516 return nativeResponseValue;
29518 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29520 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
29521 if(!isWasmInitialized) {
29522 throw new Error("initializeWasm() must be awaited first!");
29524 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
29525 // debug statements here
29527 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29529 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
29530 if(!isWasmInitialized) {
29531 throw new Error("initializeWasm() must be awaited first!");
29533 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
29534 return nativeResponseValue;
29536 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
29538 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
29539 if(!isWasmInitialized) {
29540 throw new Error("initializeWasm() must be awaited first!");
29542 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
29543 // debug statements here
29545 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
29547 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
29548 if(!isWasmInitialized) {
29549 throw new Error("initializeWasm() must be awaited first!");
29551 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
29552 return nativeResponseValue;
29554 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
29556 export function ChannelInfo_clone(orig: bigint): bigint {
29557 if(!isWasmInitialized) {
29558 throw new Error("initializeWasm() must be awaited first!");
29560 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
29561 return nativeResponseValue;
29563 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
29565 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
29566 if(!isWasmInitialized) {
29567 throw new Error("initializeWasm() must be awaited first!");
29569 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
29570 return nativeResponseValue;
29572 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
29574 export function ChannelInfo_write(obj: bigint): number {
29575 if(!isWasmInitialized) {
29576 throw new Error("initializeWasm() must be awaited first!");
29578 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
29579 return nativeResponseValue;
29581 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
29583 export function ChannelInfo_read(ser: number): bigint {
29584 if(!isWasmInitialized) {
29585 throw new Error("initializeWasm() must be awaited first!");
29587 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
29588 return nativeResponseValue;
29590 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
29592 export function DirectedChannelInfo_free(this_obj: bigint): void {
29593 if(!isWasmInitialized) {
29594 throw new Error("initializeWasm() must be awaited first!");
29596 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
29597 // debug statements here
29599 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
29601 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
29602 if(!isWasmInitialized) {
29603 throw new Error("initializeWasm() must be awaited first!");
29605 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
29606 return nativeResponseValue;
29608 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
29610 export function DirectedChannelInfo_clone(orig: bigint): bigint {
29611 if(!isWasmInitialized) {
29612 throw new Error("initializeWasm() must be awaited first!");
29614 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
29615 return nativeResponseValue;
29617 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29619 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
29620 if(!isWasmInitialized) {
29621 throw new Error("initializeWasm() must be awaited first!");
29623 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
29624 return nativeResponseValue;
29626 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29628 export function DirectedChannelInfo_direction(this_arg: bigint): bigint {
29629 if(!isWasmInitialized) {
29630 throw new Error("initializeWasm() must be awaited first!");
29632 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
29633 return nativeResponseValue;
29635 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29637 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
29638 if(!isWasmInitialized) {
29639 throw new Error("initializeWasm() must be awaited first!");
29641 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
29642 return nativeResponseValue;
29644 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29646 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
29647 if(!isWasmInitialized) {
29648 throw new Error("initializeWasm() must be awaited first!");
29650 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
29651 return nativeResponseValue;
29653 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
29655 export function EffectiveCapacity_free(this_ptr: bigint): void {
29656 if(!isWasmInitialized) {
29657 throw new Error("initializeWasm() must be awaited first!");
29659 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
29660 // debug statements here
29662 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
29664 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
29665 if(!isWasmInitialized) {
29666 throw new Error("initializeWasm() must be awaited first!");
29668 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
29669 return nativeResponseValue;
29671 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
29673 export function EffectiveCapacity_clone(orig: bigint): bigint {
29674 if(!isWasmInitialized) {
29675 throw new Error("initializeWasm() must be awaited first!");
29677 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
29678 return nativeResponseValue;
29680 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
29682 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
29683 if(!isWasmInitialized) {
29684 throw new Error("initializeWasm() must be awaited first!");
29686 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
29687 return nativeResponseValue;
29689 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
29691 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): bigint {
29692 if(!isWasmInitialized) {
29693 throw new Error("initializeWasm() must be awaited first!");
29695 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
29696 return nativeResponseValue;
29698 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
29700 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
29701 if(!isWasmInitialized) {
29702 throw new Error("initializeWasm() must be awaited first!");
29704 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
29705 return nativeResponseValue;
29707 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
29709 export function EffectiveCapacity_infinite(): bigint {
29710 if(!isWasmInitialized) {
29711 throw new Error("initializeWasm() must be awaited first!");
29713 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
29714 return nativeResponseValue;
29716 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
29718 export function EffectiveCapacity_unknown(): bigint {
29719 if(!isWasmInitialized) {
29720 throw new Error("initializeWasm() must be awaited first!");
29722 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
29723 return nativeResponseValue;
29725 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
29727 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
29728 if(!isWasmInitialized) {
29729 throw new Error("initializeWasm() must be awaited first!");
29731 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
29732 return nativeResponseValue;
29734 // void RoutingFees_free(struct LDKRoutingFees this_obj);
29736 export function RoutingFees_free(this_obj: bigint): void {
29737 if(!isWasmInitialized) {
29738 throw new Error("initializeWasm() must be awaited first!");
29740 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
29741 // debug statements here
29743 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29745 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
29746 if(!isWasmInitialized) {
29747 throw new Error("initializeWasm() must be awaited first!");
29749 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
29750 return nativeResponseValue;
29752 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29754 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
29755 if(!isWasmInitialized) {
29756 throw new Error("initializeWasm() must be awaited first!");
29758 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
29759 // debug statements here
29761 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29763 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
29764 if(!isWasmInitialized) {
29765 throw new Error("initializeWasm() must be awaited first!");
29767 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
29768 return nativeResponseValue;
29770 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29772 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
29773 if(!isWasmInitialized) {
29774 throw new Error("initializeWasm() must be awaited first!");
29776 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
29777 // debug statements here
29779 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
29781 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
29782 if(!isWasmInitialized) {
29783 throw new Error("initializeWasm() must be awaited first!");
29785 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
29786 return nativeResponseValue;
29788 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
29790 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
29791 if(!isWasmInitialized) {
29792 throw new Error("initializeWasm() must be awaited first!");
29794 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
29795 return nativeResponseValue;
29797 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
29799 export function RoutingFees_clone_ptr(arg: bigint): bigint {
29800 if(!isWasmInitialized) {
29801 throw new Error("initializeWasm() must be awaited first!");
29803 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
29804 return nativeResponseValue;
29806 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
29808 export function RoutingFees_clone(orig: bigint): bigint {
29809 if(!isWasmInitialized) {
29810 throw new Error("initializeWasm() must be awaited first!");
29812 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
29813 return nativeResponseValue;
29815 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
29817 export function RoutingFees_hash(o: bigint): bigint {
29818 if(!isWasmInitialized) {
29819 throw new Error("initializeWasm() must be awaited first!");
29821 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
29822 return nativeResponseValue;
29824 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
29826 export function RoutingFees_write(obj: bigint): number {
29827 if(!isWasmInitialized) {
29828 throw new Error("initializeWasm() must be awaited first!");
29830 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
29831 return nativeResponseValue;
29833 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
29835 export function RoutingFees_read(ser: number): bigint {
29836 if(!isWasmInitialized) {
29837 throw new Error("initializeWasm() must be awaited first!");
29839 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
29840 return nativeResponseValue;
29842 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
29844 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
29845 if(!isWasmInitialized) {
29846 throw new Error("initializeWasm() must be awaited first!");
29848 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
29849 // debug statements here
29851 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29853 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
29854 if(!isWasmInitialized) {
29855 throw new Error("initializeWasm() must be awaited first!");
29857 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
29858 return nativeResponseValue;
29860 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29862 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
29863 if(!isWasmInitialized) {
29864 throw new Error("initializeWasm() must be awaited first!");
29866 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
29867 // debug statements here
29869 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29871 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
29872 if(!isWasmInitialized) {
29873 throw new Error("initializeWasm() must be awaited first!");
29875 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
29876 return nativeResponseValue;
29878 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29880 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
29881 if(!isWasmInitialized) {
29882 throw new Error("initializeWasm() must be awaited first!");
29884 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29885 // debug statements here
29887 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29889 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
29890 if(!isWasmInitialized) {
29891 throw new Error("initializeWasm() must be awaited first!");
29893 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29894 return nativeResponseValue;
29896 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29898 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
29899 if(!isWasmInitialized) {
29900 throw new Error("initializeWasm() must be awaited first!");
29902 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29903 // debug statements here
29905 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29907 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
29908 if(!isWasmInitialized) {
29909 throw new Error("initializeWasm() must be awaited first!");
29911 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29912 return nativeResponseValue;
29914 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
29916 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
29917 if(!isWasmInitialized) {
29918 throw new Error("initializeWasm() must be awaited first!");
29920 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29921 // debug statements here
29923 // struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29925 export function NodeAnnouncementInfo_get_addresses(this_ptr: bigint): number {
29926 if(!isWasmInitialized) {
29927 throw new Error("initializeWasm() must be awaited first!");
29929 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
29930 return nativeResponseValue;
29932 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29934 export function NodeAnnouncementInfo_set_addresses(this_ptr: bigint, val: number): void {
29935 if(!isWasmInitialized) {
29936 throw new Error("initializeWasm() must be awaited first!");
29938 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29939 // debug statements here
29941 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29943 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
29944 if(!isWasmInitialized) {
29945 throw new Error("initializeWasm() must be awaited first!");
29947 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29948 return nativeResponseValue;
29950 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29952 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
29953 if(!isWasmInitialized) {
29954 throw new Error("initializeWasm() must be awaited first!");
29956 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29957 // debug statements here
29959 // MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
29961 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, addresses_arg: number, announcement_message_arg: bigint): bigint {
29962 if(!isWasmInitialized) {
29963 throw new Error("initializeWasm() must be awaited first!");
29965 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29966 return nativeResponseValue;
29968 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29970 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
29971 if(!isWasmInitialized) {
29972 throw new Error("initializeWasm() must be awaited first!");
29974 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29975 return nativeResponseValue;
29977 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29979 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
29980 if(!isWasmInitialized) {
29981 throw new Error("initializeWasm() must be awaited first!");
29983 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29984 return nativeResponseValue;
29986 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29988 export function NodeAnnouncementInfo_write(obj: bigint): number {
29989 if(!isWasmInitialized) {
29990 throw new Error("initializeWasm() must be awaited first!");
29992 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29993 return nativeResponseValue;
29995 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29997 export function NodeAnnouncementInfo_read(ser: number): bigint {
29998 if(!isWasmInitialized) {
29999 throw new Error("initializeWasm() must be awaited first!");
30001 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
30002 return nativeResponseValue;
30004 // void NodeAlias_free(struct LDKNodeAlias this_obj);
30006 export function NodeAlias_free(this_obj: bigint): void {
30007 if(!isWasmInitialized) {
30008 throw new Error("initializeWasm() must be awaited first!");
30010 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
30011 // debug statements here
30013 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
30015 export function NodeAlias_get_a(this_ptr: bigint): number {
30016 if(!isWasmInitialized) {
30017 throw new Error("initializeWasm() must be awaited first!");
30019 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
30020 return nativeResponseValue;
30022 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30024 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
30025 if(!isWasmInitialized) {
30026 throw new Error("initializeWasm() must be awaited first!");
30028 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
30029 // debug statements here
30031 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
30033 export function NodeAlias_new(a_arg: number): bigint {
30034 if(!isWasmInitialized) {
30035 throw new Error("initializeWasm() must be awaited first!");
30037 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
30038 return nativeResponseValue;
30040 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
30042 export function NodeAlias_clone_ptr(arg: bigint): bigint {
30043 if(!isWasmInitialized) {
30044 throw new Error("initializeWasm() must be awaited first!");
30046 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
30047 return nativeResponseValue;
30049 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
30051 export function NodeAlias_clone(orig: bigint): bigint {
30052 if(!isWasmInitialized) {
30053 throw new Error("initializeWasm() must be awaited first!");
30055 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
30056 return nativeResponseValue;
30058 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
30060 export function NodeAlias_write(obj: bigint): number {
30061 if(!isWasmInitialized) {
30062 throw new Error("initializeWasm() must be awaited first!");
30064 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
30065 return nativeResponseValue;
30067 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
30069 export function NodeAlias_read(ser: number): bigint {
30070 if(!isWasmInitialized) {
30071 throw new Error("initializeWasm() must be awaited first!");
30073 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
30074 return nativeResponseValue;
30076 // void NodeInfo_free(struct LDKNodeInfo this_obj);
30078 export function NodeInfo_free(this_obj: bigint): void {
30079 if(!isWasmInitialized) {
30080 throw new Error("initializeWasm() must be awaited first!");
30082 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
30083 // debug statements here
30085 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30087 export function NodeInfo_get_channels(this_ptr: bigint): number {
30088 if(!isWasmInitialized) {
30089 throw new Error("initializeWasm() must be awaited first!");
30091 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
30092 return nativeResponseValue;
30094 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
30096 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
30097 if(!isWasmInitialized) {
30098 throw new Error("initializeWasm() must be awaited first!");
30100 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
30101 // debug statements here
30103 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30105 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: bigint): bigint {
30106 if(!isWasmInitialized) {
30107 throw new Error("initializeWasm() must be awaited first!");
30109 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
30110 return nativeResponseValue;
30112 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30114 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: bigint, val: bigint): void {
30115 if(!isWasmInitialized) {
30116 throw new Error("initializeWasm() must be awaited first!");
30118 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
30119 // debug statements here
30121 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30123 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
30124 if(!isWasmInitialized) {
30125 throw new Error("initializeWasm() must be awaited first!");
30127 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
30128 return nativeResponseValue;
30130 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
30132 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
30133 if(!isWasmInitialized) {
30134 throw new Error("initializeWasm() must be awaited first!");
30136 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
30137 // debug statements here
30139 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
30141 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: bigint, announcement_info_arg: bigint): bigint {
30142 if(!isWasmInitialized) {
30143 throw new Error("initializeWasm() must be awaited first!");
30145 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
30146 return nativeResponseValue;
30148 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
30150 export function NodeInfo_clone_ptr(arg: bigint): bigint {
30151 if(!isWasmInitialized) {
30152 throw new Error("initializeWasm() must be awaited first!");
30154 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
30155 return nativeResponseValue;
30157 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
30159 export function NodeInfo_clone(orig: bigint): bigint {
30160 if(!isWasmInitialized) {
30161 throw new Error("initializeWasm() must be awaited first!");
30163 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
30164 return nativeResponseValue;
30166 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
30168 export function NodeInfo_write(obj: bigint): number {
30169 if(!isWasmInitialized) {
30170 throw new Error("initializeWasm() must be awaited first!");
30172 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
30173 return nativeResponseValue;
30175 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
30177 export function NodeInfo_read(ser: number): bigint {
30178 if(!isWasmInitialized) {
30179 throw new Error("initializeWasm() must be awaited first!");
30181 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
30182 return nativeResponseValue;
30184 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
30186 export function NetworkGraph_write(obj: bigint): number {
30187 if(!isWasmInitialized) {
30188 throw new Error("initializeWasm() must be awaited first!");
30190 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
30191 return nativeResponseValue;
30193 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
30195 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
30196 if(!isWasmInitialized) {
30197 throw new Error("initializeWasm() must be awaited first!");
30199 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
30200 return nativeResponseValue;
30202 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
30204 export function NetworkGraph_new(genesis_hash: number, logger: bigint): bigint {
30205 if(!isWasmInitialized) {
30206 throw new Error("initializeWasm() must be awaited first!");
30208 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
30209 return nativeResponseValue;
30211 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30213 export function NetworkGraph_read_only(this_arg: bigint): bigint {
30214 if(!isWasmInitialized) {
30215 throw new Error("initializeWasm() must be awaited first!");
30217 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
30218 return nativeResponseValue;
30220 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30222 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
30223 if(!isWasmInitialized) {
30224 throw new Error("initializeWasm() must be awaited first!");
30226 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
30227 return nativeResponseValue;
30229 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
30231 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
30232 if(!isWasmInitialized) {
30233 throw new Error("initializeWasm() must be awaited first!");
30235 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
30236 // debug statements here
30238 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
30240 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
30241 if(!isWasmInitialized) {
30242 throw new Error("initializeWasm() must be awaited first!");
30244 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
30245 return nativeResponseValue;
30247 // 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);
30249 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
30250 if(!isWasmInitialized) {
30251 throw new Error("initializeWasm() must be awaited first!");
30253 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
30254 return nativeResponseValue;
30256 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_AccessZ chain_access);
30258 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
30259 if(!isWasmInitialized) {
30260 throw new Error("initializeWasm() must be awaited first!");
30262 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
30263 return nativeResponseValue;
30265 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_AccessZ chain_access);
30267 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, chain_access: bigint): bigint {
30268 if(!isWasmInitialized) {
30269 throw new Error("initializeWasm() must be awaited first!");
30271 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
30272 return nativeResponseValue;
30274 // 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);
30276 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 {
30277 if(!isWasmInitialized) {
30278 throw new Error("initializeWasm() must be awaited first!");
30280 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
30281 return nativeResponseValue;
30283 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
30285 export function NetworkGraph_channel_failed(this_arg: bigint, short_channel_id: bigint, is_permanent: boolean): void {
30286 if(!isWasmInitialized) {
30287 throw new Error("initializeWasm() must be awaited first!");
30289 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
30290 // debug statements here
30292 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
30294 export function NetworkGraph_node_failed(this_arg: bigint, _node_id: number, is_permanent: boolean): void {
30295 if(!isWasmInitialized) {
30296 throw new Error("initializeWasm() must be awaited first!");
30298 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
30299 // debug statements here
30301 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
30303 export function NetworkGraph_remove_stale_channels_with_time(this_arg: bigint, current_time_unix: bigint): void {
30304 if(!isWasmInitialized) {
30305 throw new Error("initializeWasm() must be awaited first!");
30307 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
30308 // debug statements here
30310 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
30312 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
30313 if(!isWasmInitialized) {
30314 throw new Error("initializeWasm() must be awaited first!");
30316 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
30317 return nativeResponseValue;
30319 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
30321 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
30322 if(!isWasmInitialized) {
30323 throw new Error("initializeWasm() must be awaited first!");
30325 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
30326 return nativeResponseValue;
30328 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
30330 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
30331 if(!isWasmInitialized) {
30332 throw new Error("initializeWasm() must be awaited first!");
30334 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
30335 return nativeResponseValue;
30337 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
30339 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
30340 if(!isWasmInitialized) {
30341 throw new Error("initializeWasm() must be awaited first!");
30343 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
30344 return nativeResponseValue;
30346 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30348 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
30349 if(!isWasmInitialized) {
30350 throw new Error("initializeWasm() must be awaited first!");
30352 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
30353 return nativeResponseValue;
30355 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
30357 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
30358 if(!isWasmInitialized) {
30359 throw new Error("initializeWasm() must be awaited first!");
30361 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
30362 return nativeResponseValue;
30364 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
30366 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
30367 if(!isWasmInitialized) {
30368 throw new Error("initializeWasm() must be awaited first!");
30370 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
30371 return nativeResponseValue;
30373 // void RouteHop_free(struct LDKRouteHop this_obj);
30375 export function RouteHop_free(this_obj: bigint): void {
30376 if(!isWasmInitialized) {
30377 throw new Error("initializeWasm() must be awaited first!");
30379 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
30380 // debug statements here
30382 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30384 export function RouteHop_get_pubkey(this_ptr: bigint): number {
30385 if(!isWasmInitialized) {
30386 throw new Error("initializeWasm() must be awaited first!");
30388 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
30389 return nativeResponseValue;
30391 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30393 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
30394 if(!isWasmInitialized) {
30395 throw new Error("initializeWasm() must be awaited first!");
30397 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
30398 // debug statements here
30400 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30402 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
30403 if(!isWasmInitialized) {
30404 throw new Error("initializeWasm() must be awaited first!");
30406 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
30407 return nativeResponseValue;
30409 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
30411 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
30412 if(!isWasmInitialized) {
30413 throw new Error("initializeWasm() must be awaited first!");
30415 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
30416 // debug statements here
30418 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30420 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
30421 if(!isWasmInitialized) {
30422 throw new Error("initializeWasm() must be awaited first!");
30424 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
30425 return nativeResponseValue;
30427 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
30429 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
30430 if(!isWasmInitialized) {
30431 throw new Error("initializeWasm() must be awaited first!");
30433 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
30434 // debug statements here
30436 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30438 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
30439 if(!isWasmInitialized) {
30440 throw new Error("initializeWasm() must be awaited first!");
30442 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
30443 return nativeResponseValue;
30445 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
30447 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
30448 if(!isWasmInitialized) {
30449 throw new Error("initializeWasm() must be awaited first!");
30451 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
30452 // debug statements here
30454 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30456 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
30457 if(!isWasmInitialized) {
30458 throw new Error("initializeWasm() must be awaited first!");
30460 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
30461 return nativeResponseValue;
30463 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
30465 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
30466 if(!isWasmInitialized) {
30467 throw new Error("initializeWasm() must be awaited first!");
30469 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
30470 // debug statements here
30472 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30474 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
30475 if(!isWasmInitialized) {
30476 throw new Error("initializeWasm() must be awaited first!");
30478 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
30479 return nativeResponseValue;
30481 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
30483 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
30484 if(!isWasmInitialized) {
30485 throw new Error("initializeWasm() must be awaited first!");
30487 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
30488 // debug statements here
30490 // 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);
30492 export function RouteHop_new(pubkey_arg: number, node_features_arg: bigint, short_channel_id_arg: bigint, channel_features_arg: bigint, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): bigint {
30493 if(!isWasmInitialized) {
30494 throw new Error("initializeWasm() must be awaited first!");
30496 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);
30497 return nativeResponseValue;
30499 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
30501 export function RouteHop_clone_ptr(arg: bigint): bigint {
30502 if(!isWasmInitialized) {
30503 throw new Error("initializeWasm() must be awaited first!");
30505 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
30506 return nativeResponseValue;
30508 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
30510 export function RouteHop_clone(orig: bigint): bigint {
30511 if(!isWasmInitialized) {
30512 throw new Error("initializeWasm() must be awaited first!");
30514 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
30515 return nativeResponseValue;
30517 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
30519 export function RouteHop_hash(o: bigint): bigint {
30520 if(!isWasmInitialized) {
30521 throw new Error("initializeWasm() must be awaited first!");
30523 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
30524 return nativeResponseValue;
30526 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
30528 export function RouteHop_eq(a: bigint, b: bigint): boolean {
30529 if(!isWasmInitialized) {
30530 throw new Error("initializeWasm() must be awaited first!");
30532 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
30533 return nativeResponseValue;
30535 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
30537 export function RouteHop_write(obj: bigint): number {
30538 if(!isWasmInitialized) {
30539 throw new Error("initializeWasm() must be awaited first!");
30541 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
30542 return nativeResponseValue;
30544 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
30546 export function RouteHop_read(ser: number): bigint {
30547 if(!isWasmInitialized) {
30548 throw new Error("initializeWasm() must be awaited first!");
30550 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
30551 return nativeResponseValue;
30553 // void Route_free(struct LDKRoute this_obj);
30555 export function Route_free(this_obj: bigint): void {
30556 if(!isWasmInitialized) {
30557 throw new Error("initializeWasm() must be awaited first!");
30559 const nativeResponseValue = wasm.TS_Route_free(this_obj);
30560 // debug statements here
30562 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
30564 export function Route_get_paths(this_ptr: bigint): number {
30565 if(!isWasmInitialized) {
30566 throw new Error("initializeWasm() must be awaited first!");
30568 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
30569 return nativeResponseValue;
30571 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
30573 export function Route_set_paths(this_ptr: bigint, val: number): void {
30574 if(!isWasmInitialized) {
30575 throw new Error("initializeWasm() must be awaited first!");
30577 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
30578 // debug statements here
30580 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
30582 export function Route_get_payment_params(this_ptr: bigint): bigint {
30583 if(!isWasmInitialized) {
30584 throw new Error("initializeWasm() must be awaited first!");
30586 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
30587 return nativeResponseValue;
30589 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30591 export function Route_set_payment_params(this_ptr: bigint, val: bigint): void {
30592 if(!isWasmInitialized) {
30593 throw new Error("initializeWasm() must be awaited first!");
30595 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
30596 // debug statements here
30598 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
30600 export function Route_new(paths_arg: number, payment_params_arg: bigint): bigint {
30601 if(!isWasmInitialized) {
30602 throw new Error("initializeWasm() must be awaited first!");
30604 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
30605 return nativeResponseValue;
30607 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
30609 export function Route_clone_ptr(arg: bigint): bigint {
30610 if(!isWasmInitialized) {
30611 throw new Error("initializeWasm() must be awaited first!");
30613 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
30614 return nativeResponseValue;
30616 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
30618 export function Route_clone(orig: bigint): bigint {
30619 if(!isWasmInitialized) {
30620 throw new Error("initializeWasm() must be awaited first!");
30622 const nativeResponseValue = wasm.TS_Route_clone(orig);
30623 return nativeResponseValue;
30625 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
30627 export function Route_hash(o: bigint): bigint {
30628 if(!isWasmInitialized) {
30629 throw new Error("initializeWasm() must be awaited first!");
30631 const nativeResponseValue = wasm.TS_Route_hash(o);
30632 return nativeResponseValue;
30634 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
30636 export function Route_eq(a: bigint, b: bigint): boolean {
30637 if(!isWasmInitialized) {
30638 throw new Error("initializeWasm() must be awaited first!");
30640 const nativeResponseValue = wasm.TS_Route_eq(a, b);
30641 return nativeResponseValue;
30643 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
30645 export function Route_get_total_fees(this_arg: bigint): bigint {
30646 if(!isWasmInitialized) {
30647 throw new Error("initializeWasm() must be awaited first!");
30649 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
30650 return nativeResponseValue;
30652 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
30654 export function Route_get_total_amount(this_arg: bigint): bigint {
30655 if(!isWasmInitialized) {
30656 throw new Error("initializeWasm() must be awaited first!");
30658 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
30659 return nativeResponseValue;
30661 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
30663 export function Route_write(obj: bigint): number {
30664 if(!isWasmInitialized) {
30665 throw new Error("initializeWasm() must be awaited first!");
30667 const nativeResponseValue = wasm.TS_Route_write(obj);
30668 return nativeResponseValue;
30670 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
30672 export function Route_read(ser: number): bigint {
30673 if(!isWasmInitialized) {
30674 throw new Error("initializeWasm() must be awaited first!");
30676 const nativeResponseValue = wasm.TS_Route_read(ser);
30677 return nativeResponseValue;
30679 // void RouteParameters_free(struct LDKRouteParameters this_obj);
30681 export function RouteParameters_free(this_obj: bigint): void {
30682 if(!isWasmInitialized) {
30683 throw new Error("initializeWasm() must be awaited first!");
30685 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
30686 // debug statements here
30688 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30690 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
30691 if(!isWasmInitialized) {
30692 throw new Error("initializeWasm() must be awaited first!");
30694 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
30695 return nativeResponseValue;
30697 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30699 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
30700 if(!isWasmInitialized) {
30701 throw new Error("initializeWasm() must be awaited first!");
30703 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
30704 // debug statements here
30706 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30708 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
30709 if(!isWasmInitialized) {
30710 throw new Error("initializeWasm() must be awaited first!");
30712 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
30713 return nativeResponseValue;
30715 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
30717 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
30718 if(!isWasmInitialized) {
30719 throw new Error("initializeWasm() must be awaited first!");
30721 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
30722 // debug statements here
30724 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30726 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: bigint): number {
30727 if(!isWasmInitialized) {
30728 throw new Error("initializeWasm() must be awaited first!");
30730 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
30731 return nativeResponseValue;
30733 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
30735 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
30736 if(!isWasmInitialized) {
30737 throw new Error("initializeWasm() must be awaited first!");
30739 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
30740 // debug statements here
30742 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg, uint32_t final_cltv_expiry_delta_arg);
30744 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): bigint {
30745 if(!isWasmInitialized) {
30746 throw new Error("initializeWasm() must be awaited first!");
30748 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
30749 return nativeResponseValue;
30751 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
30753 export function RouteParameters_clone_ptr(arg: bigint): bigint {
30754 if(!isWasmInitialized) {
30755 throw new Error("initializeWasm() must be awaited first!");
30757 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
30758 return nativeResponseValue;
30760 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
30762 export function RouteParameters_clone(orig: bigint): bigint {
30763 if(!isWasmInitialized) {
30764 throw new Error("initializeWasm() must be awaited first!");
30766 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
30767 return nativeResponseValue;
30769 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
30771 export function RouteParameters_write(obj: bigint): number {
30772 if(!isWasmInitialized) {
30773 throw new Error("initializeWasm() must be awaited first!");
30775 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
30776 return nativeResponseValue;
30778 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
30780 export function RouteParameters_read(ser: number): bigint {
30781 if(!isWasmInitialized) {
30782 throw new Error("initializeWasm() must be awaited first!");
30784 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
30785 return nativeResponseValue;
30787 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
30789 export function PaymentParameters_free(this_obj: bigint): void {
30790 if(!isWasmInitialized) {
30791 throw new Error("initializeWasm() must be awaited first!");
30793 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
30794 // debug statements here
30796 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30798 export function PaymentParameters_get_payee_pubkey(this_ptr: bigint): number {
30799 if(!isWasmInitialized) {
30800 throw new Error("initializeWasm() must be awaited first!");
30802 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
30803 return nativeResponseValue;
30805 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30807 export function PaymentParameters_set_payee_pubkey(this_ptr: bigint, val: number): void {
30808 if(!isWasmInitialized) {
30809 throw new Error("initializeWasm() must be awaited first!");
30811 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
30812 // debug statements here
30814 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30816 export function PaymentParameters_get_features(this_ptr: bigint): bigint {
30817 if(!isWasmInitialized) {
30818 throw new Error("initializeWasm() must be awaited first!");
30820 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
30821 return nativeResponseValue;
30823 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
30825 export function PaymentParameters_set_features(this_ptr: bigint, val: bigint): void {
30826 if(!isWasmInitialized) {
30827 throw new Error("initializeWasm() must be awaited first!");
30829 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
30830 // debug statements here
30832 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30834 export function PaymentParameters_get_route_hints(this_ptr: bigint): number {
30835 if(!isWasmInitialized) {
30836 throw new Error("initializeWasm() must be awaited first!");
30838 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
30839 return nativeResponseValue;
30841 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
30843 export function PaymentParameters_set_route_hints(this_ptr: bigint, val: number): void {
30844 if(!isWasmInitialized) {
30845 throw new Error("initializeWasm() must be awaited first!");
30847 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
30848 // debug statements here
30850 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30852 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
30853 if(!isWasmInitialized) {
30854 throw new Error("initializeWasm() must be awaited first!");
30856 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
30857 return nativeResponseValue;
30859 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30861 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
30862 if(!isWasmInitialized) {
30863 throw new Error("initializeWasm() must be awaited first!");
30865 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
30866 // debug statements here
30868 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30870 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
30871 if(!isWasmInitialized) {
30872 throw new Error("initializeWasm() must be awaited first!");
30874 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
30875 return nativeResponseValue;
30877 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
30879 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
30880 if(!isWasmInitialized) {
30881 throw new Error("initializeWasm() must be awaited first!");
30883 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
30884 // debug statements here
30886 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30888 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
30889 if(!isWasmInitialized) {
30890 throw new Error("initializeWasm() must be awaited first!");
30892 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
30893 return nativeResponseValue;
30895 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30897 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
30898 if(!isWasmInitialized) {
30899 throw new Error("initializeWasm() must be awaited first!");
30901 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
30902 // debug statements here
30904 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30906 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
30907 if(!isWasmInitialized) {
30908 throw new Error("initializeWasm() must be awaited first!");
30910 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
30911 return nativeResponseValue;
30913 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30915 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
30916 if(!isWasmInitialized) {
30917 throw new Error("initializeWasm() must be awaited first!");
30919 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
30920 // debug statements here
30922 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30924 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
30925 if(!isWasmInitialized) {
30926 throw new Error("initializeWasm() must be awaited first!");
30928 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
30929 return nativeResponseValue;
30931 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
30933 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
30934 if(!isWasmInitialized) {
30935 throw new Error("initializeWasm() must be awaited first!");
30937 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
30938 // debug statements here
30940 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg);
30942 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: bigint, route_hints_arg: number, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number): bigint {
30943 if(!isWasmInitialized) {
30944 throw new Error("initializeWasm() must be awaited first!");
30946 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg);
30947 return nativeResponseValue;
30949 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
30951 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
30952 if(!isWasmInitialized) {
30953 throw new Error("initializeWasm() must be awaited first!");
30955 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
30956 return nativeResponseValue;
30958 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
30960 export function PaymentParameters_clone(orig: bigint): bigint {
30961 if(!isWasmInitialized) {
30962 throw new Error("initializeWasm() must be awaited first!");
30964 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
30965 return nativeResponseValue;
30967 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
30969 export function PaymentParameters_hash(o: bigint): bigint {
30970 if(!isWasmInitialized) {
30971 throw new Error("initializeWasm() must be awaited first!");
30973 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
30974 return nativeResponseValue;
30976 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
30978 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
30979 if(!isWasmInitialized) {
30980 throw new Error("initializeWasm() must be awaited first!");
30982 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
30983 return nativeResponseValue;
30985 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
30987 export function PaymentParameters_write(obj: bigint): number {
30988 if(!isWasmInitialized) {
30989 throw new Error("initializeWasm() must be awaited first!");
30991 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
30992 return nativeResponseValue;
30994 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
30996 export function PaymentParameters_read(ser: number): bigint {
30997 if(!isWasmInitialized) {
30998 throw new Error("initializeWasm() must be awaited first!");
31000 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
31001 return nativeResponseValue;
31003 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
31005 export function PaymentParameters_from_node_id(payee_pubkey: number): bigint {
31006 if(!isWasmInitialized) {
31007 throw new Error("initializeWasm() must be awaited first!");
31009 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
31010 return nativeResponseValue;
31012 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
31014 export function PaymentParameters_for_keysend(payee_pubkey: number): bigint {
31015 if(!isWasmInitialized) {
31016 throw new Error("initializeWasm() must be awaited first!");
31018 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
31019 return nativeResponseValue;
31021 // void RouteHint_free(struct LDKRouteHint this_obj);
31023 export function RouteHint_free(this_obj: bigint): void {
31024 if(!isWasmInitialized) {
31025 throw new Error("initializeWasm() must be awaited first!");
31027 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
31028 // debug statements here
31030 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
31032 export function RouteHint_get_a(this_ptr: bigint): number {
31033 if(!isWasmInitialized) {
31034 throw new Error("initializeWasm() must be awaited first!");
31036 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
31037 return nativeResponseValue;
31039 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
31041 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
31042 if(!isWasmInitialized) {
31043 throw new Error("initializeWasm() must be awaited first!");
31045 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
31046 // debug statements here
31048 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
31050 export function RouteHint_new(a_arg: number): bigint {
31051 if(!isWasmInitialized) {
31052 throw new Error("initializeWasm() must be awaited first!");
31054 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
31055 return nativeResponseValue;
31057 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
31059 export function RouteHint_clone_ptr(arg: bigint): bigint {
31060 if(!isWasmInitialized) {
31061 throw new Error("initializeWasm() must be awaited first!");
31063 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
31064 return nativeResponseValue;
31066 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
31068 export function RouteHint_clone(orig: bigint): bigint {
31069 if(!isWasmInitialized) {
31070 throw new Error("initializeWasm() must be awaited first!");
31072 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
31073 return nativeResponseValue;
31075 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
31077 export function RouteHint_hash(o: bigint): bigint {
31078 if(!isWasmInitialized) {
31079 throw new Error("initializeWasm() must be awaited first!");
31081 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
31082 return nativeResponseValue;
31084 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
31086 export function RouteHint_eq(a: bigint, b: bigint): boolean {
31087 if(!isWasmInitialized) {
31088 throw new Error("initializeWasm() must be awaited first!");
31090 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
31091 return nativeResponseValue;
31093 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
31095 export function RouteHint_write(obj: bigint): number {
31096 if(!isWasmInitialized) {
31097 throw new Error("initializeWasm() must be awaited first!");
31099 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
31100 return nativeResponseValue;
31102 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
31104 export function RouteHint_read(ser: number): bigint {
31105 if(!isWasmInitialized) {
31106 throw new Error("initializeWasm() must be awaited first!");
31108 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
31109 return nativeResponseValue;
31111 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
31113 export function RouteHintHop_free(this_obj: bigint): void {
31114 if(!isWasmInitialized) {
31115 throw new Error("initializeWasm() must be awaited first!");
31117 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
31118 // debug statements here
31120 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31122 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
31123 if(!isWasmInitialized) {
31124 throw new Error("initializeWasm() must be awaited first!");
31126 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
31127 return nativeResponseValue;
31129 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31131 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
31132 if(!isWasmInitialized) {
31133 throw new Error("initializeWasm() must be awaited first!");
31135 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
31136 // debug statements here
31138 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31140 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
31141 if(!isWasmInitialized) {
31142 throw new Error("initializeWasm() must be awaited first!");
31144 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
31145 return nativeResponseValue;
31147 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
31149 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
31150 if(!isWasmInitialized) {
31151 throw new Error("initializeWasm() must be awaited first!");
31153 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
31154 // debug statements here
31156 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31158 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
31159 if(!isWasmInitialized) {
31160 throw new Error("initializeWasm() must be awaited first!");
31162 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
31163 return nativeResponseValue;
31165 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
31167 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
31168 if(!isWasmInitialized) {
31169 throw new Error("initializeWasm() must be awaited first!");
31171 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
31172 // debug statements here
31174 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31176 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
31177 if(!isWasmInitialized) {
31178 throw new Error("initializeWasm() must be awaited first!");
31180 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
31181 return nativeResponseValue;
31183 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
31185 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
31186 if(!isWasmInitialized) {
31187 throw new Error("initializeWasm() must be awaited first!");
31189 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
31190 // debug statements here
31192 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31194 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
31195 if(!isWasmInitialized) {
31196 throw new Error("initializeWasm() must be awaited first!");
31198 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
31199 return nativeResponseValue;
31201 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31203 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
31204 if(!isWasmInitialized) {
31205 throw new Error("initializeWasm() must be awaited first!");
31207 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
31208 // debug statements here
31210 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31212 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
31213 if(!isWasmInitialized) {
31214 throw new Error("initializeWasm() must be awaited first!");
31216 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
31217 return nativeResponseValue;
31219 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31221 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
31222 if(!isWasmInitialized) {
31223 throw new Error("initializeWasm() must be awaited first!");
31225 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
31226 // debug statements here
31228 // 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);
31230 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 {
31231 if(!isWasmInitialized) {
31232 throw new Error("initializeWasm() must be awaited first!");
31234 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);
31235 return nativeResponseValue;
31237 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
31239 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
31240 if(!isWasmInitialized) {
31241 throw new Error("initializeWasm() must be awaited first!");
31243 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
31244 return nativeResponseValue;
31246 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
31248 export function RouteHintHop_clone(orig: bigint): bigint {
31249 if(!isWasmInitialized) {
31250 throw new Error("initializeWasm() must be awaited first!");
31252 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
31253 return nativeResponseValue;
31255 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
31257 export function RouteHintHop_hash(o: bigint): bigint {
31258 if(!isWasmInitialized) {
31259 throw new Error("initializeWasm() must be awaited first!");
31261 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
31262 return nativeResponseValue;
31264 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
31266 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
31267 if(!isWasmInitialized) {
31268 throw new Error("initializeWasm() must be awaited first!");
31270 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
31271 return nativeResponseValue;
31273 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
31275 export function RouteHintHop_write(obj: bigint): number {
31276 if(!isWasmInitialized) {
31277 throw new Error("initializeWasm() must be awaited first!");
31279 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
31280 return nativeResponseValue;
31282 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
31284 export function RouteHintHop_read(ser: number): bigint {
31285 if(!isWasmInitialized) {
31286 throw new Error("initializeWasm() must be awaited first!");
31288 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
31289 return nativeResponseValue;
31291 // struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer, const uint8_t (*random_seed_bytes)[32]);
31293 export function find_route(our_node_pubkey: number, route_params: bigint, network_graph: bigint, first_hops: number, logger: bigint, scorer: bigint, random_seed_bytes: number): bigint {
31294 if(!isWasmInitialized) {
31295 throw new Error("initializeWasm() must be awaited first!");
31297 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
31298 return nativeResponseValue;
31300 // 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]);
31302 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 {
31303 if(!isWasmInitialized) {
31304 throw new Error("initializeWasm() must be awaited first!");
31306 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
31307 return nativeResponseValue;
31309 // void Score_free(struct LDKScore this_ptr);
31311 export function Score_free(this_ptr: bigint): void {
31312 if(!isWasmInitialized) {
31313 throw new Error("initializeWasm() must be awaited first!");
31315 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
31316 // debug statements here
31318 // void LockableScore_free(struct LDKLockableScore this_ptr);
31320 export function LockableScore_free(this_ptr: bigint): void {
31321 if(!isWasmInitialized) {
31322 throw new Error("initializeWasm() must be awaited first!");
31324 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
31325 // debug statements here
31327 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
31329 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
31330 if(!isWasmInitialized) {
31331 throw new Error("initializeWasm() must be awaited first!");
31333 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
31334 // debug statements here
31336 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
31338 export function MultiThreadedLockableScore_write(obj: bigint): number {
31339 if(!isWasmInitialized) {
31340 throw new Error("initializeWasm() must be awaited first!");
31342 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
31343 return nativeResponseValue;
31345 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
31347 export function MultiThreadedLockableScore_new(score: bigint): bigint {
31348 if(!isWasmInitialized) {
31349 throw new Error("initializeWasm() must be awaited first!");
31351 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
31352 return nativeResponseValue;
31354 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
31356 export function ChannelUsage_free(this_obj: bigint): void {
31357 if(!isWasmInitialized) {
31358 throw new Error("initializeWasm() must be awaited first!");
31360 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
31361 // debug statements here
31363 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31365 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
31366 if(!isWasmInitialized) {
31367 throw new Error("initializeWasm() must be awaited first!");
31369 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
31370 return nativeResponseValue;
31372 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
31374 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
31375 if(!isWasmInitialized) {
31376 throw new Error("initializeWasm() must be awaited first!");
31378 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
31379 // debug statements here
31381 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31383 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
31384 if(!isWasmInitialized) {
31385 throw new Error("initializeWasm() must be awaited first!");
31387 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
31388 return nativeResponseValue;
31390 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
31392 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
31393 if(!isWasmInitialized) {
31394 throw new Error("initializeWasm() must be awaited first!");
31396 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
31397 // debug statements here
31399 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31401 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
31402 if(!isWasmInitialized) {
31403 throw new Error("initializeWasm() must be awaited first!");
31405 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
31406 return nativeResponseValue;
31408 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
31410 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
31411 if(!isWasmInitialized) {
31412 throw new Error("initializeWasm() must be awaited first!");
31414 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
31415 // debug statements here
31417 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
31419 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
31420 if(!isWasmInitialized) {
31421 throw new Error("initializeWasm() must be awaited first!");
31423 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
31424 return nativeResponseValue;
31426 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
31428 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
31429 if(!isWasmInitialized) {
31430 throw new Error("initializeWasm() must be awaited first!");
31432 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
31433 return nativeResponseValue;
31435 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
31437 export function ChannelUsage_clone(orig: bigint): bigint {
31438 if(!isWasmInitialized) {
31439 throw new Error("initializeWasm() must be awaited first!");
31441 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
31442 return nativeResponseValue;
31444 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
31446 export function FixedPenaltyScorer_free(this_obj: bigint): void {
31447 if(!isWasmInitialized) {
31448 throw new Error("initializeWasm() must be awaited first!");
31450 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
31451 // debug statements here
31453 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
31455 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
31456 if(!isWasmInitialized) {
31457 throw new Error("initializeWasm() must be awaited first!");
31459 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
31460 return nativeResponseValue;
31462 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
31464 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
31465 if(!isWasmInitialized) {
31466 throw new Error("initializeWasm() must be awaited first!");
31468 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
31469 return nativeResponseValue;
31471 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
31473 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
31474 if(!isWasmInitialized) {
31475 throw new Error("initializeWasm() must be awaited first!");
31477 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
31478 return nativeResponseValue;
31480 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
31482 export function FixedPenaltyScorer_as_Score(this_arg: bigint): bigint {
31483 if(!isWasmInitialized) {
31484 throw new Error("initializeWasm() must be awaited first!");
31486 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
31487 return nativeResponseValue;
31489 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
31491 export function FixedPenaltyScorer_write(obj: bigint): number {
31492 if(!isWasmInitialized) {
31493 throw new Error("initializeWasm() must be awaited first!");
31495 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
31496 return nativeResponseValue;
31498 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
31500 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
31501 if(!isWasmInitialized) {
31502 throw new Error("initializeWasm() must be awaited first!");
31504 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
31505 return nativeResponseValue;
31507 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
31509 export function ProbabilisticScorer_free(this_obj: bigint): void {
31510 if(!isWasmInitialized) {
31511 throw new Error("initializeWasm() must be awaited first!");
31513 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
31514 // debug statements here
31516 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
31518 export function ProbabilisticScoringParameters_free(this_obj: bigint): void {
31519 if(!isWasmInitialized) {
31520 throw new Error("initializeWasm() must be awaited first!");
31522 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
31523 // debug statements here
31525 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31527 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
31528 if(!isWasmInitialized) {
31529 throw new Error("initializeWasm() must be awaited first!");
31531 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
31532 return nativeResponseValue;
31534 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31536 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
31537 if(!isWasmInitialized) {
31538 throw new Error("initializeWasm() must be awaited first!");
31540 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
31541 // debug statements here
31543 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31545 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
31546 if(!isWasmInitialized) {
31547 throw new Error("initializeWasm() must be awaited first!");
31549 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
31550 return nativeResponseValue;
31552 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31554 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
31555 if(!isWasmInitialized) {
31556 throw new Error("initializeWasm() must be awaited first!");
31558 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
31559 // debug statements here
31561 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31563 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
31564 if(!isWasmInitialized) {
31565 throw new Error("initializeWasm() must be awaited first!");
31567 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
31568 return nativeResponseValue;
31570 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31572 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
31573 if(!isWasmInitialized) {
31574 throw new Error("initializeWasm() must be awaited first!");
31576 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
31577 // debug statements here
31579 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31581 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
31582 if(!isWasmInitialized) {
31583 throw new Error("initializeWasm() must be awaited first!");
31585 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
31586 return nativeResponseValue;
31588 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31590 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
31591 if(!isWasmInitialized) {
31592 throw new Error("initializeWasm() must be awaited first!");
31594 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
31595 // debug statements here
31597 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31599 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
31600 if(!isWasmInitialized) {
31601 throw new Error("initializeWasm() must be awaited first!");
31603 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
31604 return nativeResponseValue;
31606 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31608 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
31609 if(!isWasmInitialized) {
31610 throw new Error("initializeWasm() must be awaited first!");
31612 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
31613 // debug statements here
31615 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31617 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
31618 if(!isWasmInitialized) {
31619 throw new Error("initializeWasm() must be awaited first!");
31621 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
31622 return nativeResponseValue;
31624 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31626 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
31627 if(!isWasmInitialized) {
31628 throw new Error("initializeWasm() must be awaited first!");
31630 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
31631 // debug statements here
31633 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31635 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
31636 if(!isWasmInitialized) {
31637 throw new Error("initializeWasm() must be awaited first!");
31639 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
31640 return nativeResponseValue;
31642 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31644 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
31645 if(!isWasmInitialized) {
31646 throw new Error("initializeWasm() must be awaited first!");
31648 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
31649 // debug statements here
31651 // uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
31653 export function ProbabilisticScoringParameters_clone_ptr(arg: bigint): bigint {
31654 if(!isWasmInitialized) {
31655 throw new Error("initializeWasm() must be awaited first!");
31657 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
31658 return nativeResponseValue;
31660 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
31662 export function ProbabilisticScoringParameters_clone(orig: bigint): bigint {
31663 if(!isWasmInitialized) {
31664 throw new Error("initializeWasm() must be awaited first!");
31666 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
31667 return nativeResponseValue;
31669 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
31671 export function ProbabilisticScorer_new(params: bigint, network_graph: bigint, logger: bigint): bigint {
31672 if(!isWasmInitialized) {
31673 throw new Error("initializeWasm() must be awaited first!");
31675 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
31676 return nativeResponseValue;
31678 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31680 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
31681 if(!isWasmInitialized) {
31682 throw new Error("initializeWasm() must be awaited first!");
31684 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
31685 // debug statements here
31687 // 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);
31689 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
31690 if(!isWasmInitialized) {
31691 throw new Error("initializeWasm() must be awaited first!");
31693 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
31694 return nativeResponseValue;
31696 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31698 export function ProbabilisticScorer_add_banned(this_arg: bigint, node_id: bigint): void {
31699 if(!isWasmInitialized) {
31700 throw new Error("initializeWasm() must be awaited first!");
31702 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
31703 // debug statements here
31705 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31707 export function ProbabilisticScorer_remove_banned(this_arg: bigint, node_id: bigint): void {
31708 if(!isWasmInitialized) {
31709 throw new Error("initializeWasm() must be awaited first!");
31711 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
31712 // debug statements here
31714 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
31716 export function ProbabilisticScorer_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
31717 if(!isWasmInitialized) {
31718 throw new Error("initializeWasm() must be awaited first!");
31720 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
31721 // debug statements here
31723 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31725 export function ProbabilisticScorer_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
31726 if(!isWasmInitialized) {
31727 throw new Error("initializeWasm() must be awaited first!");
31729 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
31730 // debug statements here
31732 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31734 export function ProbabilisticScorer_clear_manual_penalties(this_arg: bigint): void {
31735 if(!isWasmInitialized) {
31736 throw new Error("initializeWasm() must be awaited first!");
31738 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
31739 // debug statements here
31741 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
31743 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
31744 if(!isWasmInitialized) {
31745 throw new Error("initializeWasm() must be awaited first!");
31747 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
31748 // debug statements here
31750 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
31752 export function ProbabilisticScoringParameters_default(): bigint {
31753 if(!isWasmInitialized) {
31754 throw new Error("initializeWasm() must be awaited first!");
31756 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
31757 return nativeResponseValue;
31759 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31761 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
31762 if(!isWasmInitialized) {
31763 throw new Error("initializeWasm() must be awaited first!");
31765 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
31766 return nativeResponseValue;
31768 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
31770 export function ProbabilisticScorer_write(obj: bigint): number {
31771 if(!isWasmInitialized) {
31772 throw new Error("initializeWasm() must be awaited first!");
31774 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
31775 return nativeResponseValue;
31777 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
31779 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
31780 if(!isWasmInitialized) {
31781 throw new Error("initializeWasm() must be awaited first!");
31783 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
31784 return nativeResponseValue;
31786 // void ParseError_free(struct LDKParseError this_ptr);
31788 export function ParseError_free(this_ptr: bigint): void {
31789 if(!isWasmInitialized) {
31790 throw new Error("initializeWasm() must be awaited first!");
31792 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
31793 // debug statements here
31795 // uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
31797 export function ParseError_clone_ptr(arg: bigint): bigint {
31798 if(!isWasmInitialized) {
31799 throw new Error("initializeWasm() must be awaited first!");
31801 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
31802 return nativeResponseValue;
31804 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
31806 export function ParseError_clone(orig: bigint): bigint {
31807 if(!isWasmInitialized) {
31808 throw new Error("initializeWasm() must be awaited first!");
31810 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
31811 return nativeResponseValue;
31813 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
31815 export function ParseError_bech32_error(a: bigint): bigint {
31816 if(!isWasmInitialized) {
31817 throw new Error("initializeWasm() must be awaited first!");
31819 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
31820 return nativeResponseValue;
31822 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
31824 export function ParseError_parse_amount_error(a: number): bigint {
31825 if(!isWasmInitialized) {
31826 throw new Error("initializeWasm() must be awaited first!");
31828 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
31829 return nativeResponseValue;
31831 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
31833 export function ParseError_malformed_signature(a: Secp256k1Error): bigint {
31834 if(!isWasmInitialized) {
31835 throw new Error("initializeWasm() must be awaited first!");
31837 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
31838 return nativeResponseValue;
31840 // struct LDKParseError ParseError_bad_prefix(void);
31842 export function ParseError_bad_prefix(): bigint {
31843 if(!isWasmInitialized) {
31844 throw new Error("initializeWasm() must be awaited first!");
31846 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
31847 return nativeResponseValue;
31849 // struct LDKParseError ParseError_unknown_currency(void);
31851 export function ParseError_unknown_currency(): bigint {
31852 if(!isWasmInitialized) {
31853 throw new Error("initializeWasm() must be awaited first!");
31855 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
31856 return nativeResponseValue;
31858 // struct LDKParseError ParseError_unknown_si_prefix(void);
31860 export function ParseError_unknown_si_prefix(): bigint {
31861 if(!isWasmInitialized) {
31862 throw new Error("initializeWasm() must be awaited first!");
31864 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
31865 return nativeResponseValue;
31867 // struct LDKParseError ParseError_malformed_hrp(void);
31869 export function ParseError_malformed_hrp(): bigint {
31870 if(!isWasmInitialized) {
31871 throw new Error("initializeWasm() must be awaited first!");
31873 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
31874 return nativeResponseValue;
31876 // struct LDKParseError ParseError_too_short_data_part(void);
31878 export function ParseError_too_short_data_part(): bigint {
31879 if(!isWasmInitialized) {
31880 throw new Error("initializeWasm() must be awaited first!");
31882 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
31883 return nativeResponseValue;
31885 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
31887 export function ParseError_unexpected_end_of_tagged_fields(): bigint {
31888 if(!isWasmInitialized) {
31889 throw new Error("initializeWasm() must be awaited first!");
31891 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
31892 return nativeResponseValue;
31894 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
31896 export function ParseError_description_decode_error(a: number): bigint {
31897 if(!isWasmInitialized) {
31898 throw new Error("initializeWasm() must be awaited first!");
31900 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
31901 return nativeResponseValue;
31903 // struct LDKParseError ParseError_padding_error(void);
31905 export function ParseError_padding_error(): bigint {
31906 if(!isWasmInitialized) {
31907 throw new Error("initializeWasm() must be awaited first!");
31909 const nativeResponseValue = wasm.TS_ParseError_padding_error();
31910 return nativeResponseValue;
31912 // struct LDKParseError ParseError_integer_overflow_error(void);
31914 export function ParseError_integer_overflow_error(): bigint {
31915 if(!isWasmInitialized) {
31916 throw new Error("initializeWasm() must be awaited first!");
31918 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
31919 return nativeResponseValue;
31921 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
31923 export function ParseError_invalid_seg_wit_program_length(): bigint {
31924 if(!isWasmInitialized) {
31925 throw new Error("initializeWasm() must be awaited first!");
31927 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
31928 return nativeResponseValue;
31930 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
31932 export function ParseError_invalid_pub_key_hash_length(): bigint {
31933 if(!isWasmInitialized) {
31934 throw new Error("initializeWasm() must be awaited first!");
31936 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
31937 return nativeResponseValue;
31939 // struct LDKParseError ParseError_invalid_script_hash_length(void);
31941 export function ParseError_invalid_script_hash_length(): bigint {
31942 if(!isWasmInitialized) {
31943 throw new Error("initializeWasm() must be awaited first!");
31945 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
31946 return nativeResponseValue;
31948 // struct LDKParseError ParseError_invalid_recovery_id(void);
31950 export function ParseError_invalid_recovery_id(): bigint {
31951 if(!isWasmInitialized) {
31952 throw new Error("initializeWasm() must be awaited first!");
31954 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
31955 return nativeResponseValue;
31957 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
31959 export function ParseError_invalid_slice_length(a: number): bigint {
31960 if(!isWasmInitialized) {
31961 throw new Error("initializeWasm() must be awaited first!");
31963 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
31964 return nativeResponseValue;
31966 // struct LDKParseError ParseError_skip(void);
31968 export function ParseError_skip(): bigint {
31969 if(!isWasmInitialized) {
31970 throw new Error("initializeWasm() must be awaited first!");
31972 const nativeResponseValue = wasm.TS_ParseError_skip();
31973 return nativeResponseValue;
31975 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
31977 export function ParseOrSemanticError_free(this_ptr: bigint): void {
31978 if(!isWasmInitialized) {
31979 throw new Error("initializeWasm() must be awaited first!");
31981 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
31982 // debug statements here
31984 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
31986 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
31987 if(!isWasmInitialized) {
31988 throw new Error("initializeWasm() must be awaited first!");
31990 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
31991 return nativeResponseValue;
31993 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
31995 export function ParseOrSemanticError_clone(orig: bigint): bigint {
31996 if(!isWasmInitialized) {
31997 throw new Error("initializeWasm() must be awaited first!");
31999 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
32000 return nativeResponseValue;
32002 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
32004 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
32005 if(!isWasmInitialized) {
32006 throw new Error("initializeWasm() must be awaited first!");
32008 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
32009 return nativeResponseValue;
32011 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
32013 export function ParseOrSemanticError_semantic_error(a: SemanticError): bigint {
32014 if(!isWasmInitialized) {
32015 throw new Error("initializeWasm() must be awaited first!");
32017 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
32018 return nativeResponseValue;
32020 // void Invoice_free(struct LDKInvoice this_obj);
32022 export function Invoice_free(this_obj: bigint): void {
32023 if(!isWasmInitialized) {
32024 throw new Error("initializeWasm() must be awaited first!");
32026 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
32027 // debug statements here
32029 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
32031 export function Invoice_eq(a: bigint, b: bigint): boolean {
32032 if(!isWasmInitialized) {
32033 throw new Error("initializeWasm() must be awaited first!");
32035 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
32036 return nativeResponseValue;
32038 // uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
32040 export function Invoice_clone_ptr(arg: bigint): bigint {
32041 if(!isWasmInitialized) {
32042 throw new Error("initializeWasm() must be awaited first!");
32044 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
32045 return nativeResponseValue;
32047 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
32049 export function Invoice_clone(orig: bigint): bigint {
32050 if(!isWasmInitialized) {
32051 throw new Error("initializeWasm() must be awaited first!");
32053 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
32054 return nativeResponseValue;
32056 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
32058 export function SignedRawInvoice_free(this_obj: bigint): void {
32059 if(!isWasmInitialized) {
32060 throw new Error("initializeWasm() must be awaited first!");
32062 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
32063 // debug statements here
32065 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
32067 export function SignedRawInvoice_eq(a: bigint, b: bigint): boolean {
32068 if(!isWasmInitialized) {
32069 throw new Error("initializeWasm() must be awaited first!");
32071 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
32072 return nativeResponseValue;
32074 // uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
32076 export function SignedRawInvoice_clone_ptr(arg: bigint): bigint {
32077 if(!isWasmInitialized) {
32078 throw new Error("initializeWasm() must be awaited first!");
32080 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
32081 return nativeResponseValue;
32083 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
32085 export function SignedRawInvoice_clone(orig: bigint): bigint {
32086 if(!isWasmInitialized) {
32087 throw new Error("initializeWasm() must be awaited first!");
32089 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
32090 return nativeResponseValue;
32092 // void RawInvoice_free(struct LDKRawInvoice this_obj);
32094 export function RawInvoice_free(this_obj: bigint): void {
32095 if(!isWasmInitialized) {
32096 throw new Error("initializeWasm() must be awaited first!");
32098 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
32099 // debug statements here
32101 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
32103 export function RawInvoice_get_data(this_ptr: bigint): bigint {
32104 if(!isWasmInitialized) {
32105 throw new Error("initializeWasm() must be awaited first!");
32107 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
32108 return nativeResponseValue;
32110 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
32112 export function RawInvoice_set_data(this_ptr: bigint, val: bigint): void {
32113 if(!isWasmInitialized) {
32114 throw new Error("initializeWasm() must be awaited first!");
32116 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
32117 // debug statements here
32119 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
32121 export function RawInvoice_eq(a: bigint, b: bigint): boolean {
32122 if(!isWasmInitialized) {
32123 throw new Error("initializeWasm() must be awaited first!");
32125 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
32126 return nativeResponseValue;
32128 // uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
32130 export function RawInvoice_clone_ptr(arg: bigint): bigint {
32131 if(!isWasmInitialized) {
32132 throw new Error("initializeWasm() must be awaited first!");
32134 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
32135 return nativeResponseValue;
32137 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
32139 export function RawInvoice_clone(orig: bigint): bigint {
32140 if(!isWasmInitialized) {
32141 throw new Error("initializeWasm() must be awaited first!");
32143 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
32144 return nativeResponseValue;
32146 // void RawDataPart_free(struct LDKRawDataPart this_obj);
32148 export function RawDataPart_free(this_obj: bigint): void {
32149 if(!isWasmInitialized) {
32150 throw new Error("initializeWasm() must be awaited first!");
32152 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
32153 // debug statements here
32155 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
32157 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
32158 if(!isWasmInitialized) {
32159 throw new Error("initializeWasm() must be awaited first!");
32161 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
32162 return nativeResponseValue;
32164 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
32166 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
32167 if(!isWasmInitialized) {
32168 throw new Error("initializeWasm() must be awaited first!");
32170 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
32171 // debug statements here
32173 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
32175 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
32176 if(!isWasmInitialized) {
32177 throw new Error("initializeWasm() must be awaited first!");
32179 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
32180 return nativeResponseValue;
32182 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
32184 export function RawDataPart_clone_ptr(arg: bigint): bigint {
32185 if(!isWasmInitialized) {
32186 throw new Error("initializeWasm() must be awaited first!");
32188 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
32189 return nativeResponseValue;
32191 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
32193 export function RawDataPart_clone(orig: bigint): bigint {
32194 if(!isWasmInitialized) {
32195 throw new Error("initializeWasm() must be awaited first!");
32197 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
32198 return nativeResponseValue;
32200 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
32202 export function PositiveTimestamp_free(this_obj: bigint): void {
32203 if(!isWasmInitialized) {
32204 throw new Error("initializeWasm() must be awaited first!");
32206 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
32207 // debug statements here
32209 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
32211 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
32212 if(!isWasmInitialized) {
32213 throw new Error("initializeWasm() must be awaited first!");
32215 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
32216 return nativeResponseValue;
32218 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
32220 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
32221 if(!isWasmInitialized) {
32222 throw new Error("initializeWasm() must be awaited first!");
32224 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
32225 return nativeResponseValue;
32227 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
32229 export function PositiveTimestamp_clone(orig: bigint): bigint {
32230 if(!isWasmInitialized) {
32231 throw new Error("initializeWasm() must be awaited first!");
32233 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
32234 return nativeResponseValue;
32236 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
32238 export function SiPrefix_clone(orig: bigint): SiPrefix {
32239 if(!isWasmInitialized) {
32240 throw new Error("initializeWasm() must be awaited first!");
32242 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
32243 return nativeResponseValue;
32245 // enum LDKSiPrefix SiPrefix_milli(void);
32247 export function SiPrefix_milli(): SiPrefix {
32248 if(!isWasmInitialized) {
32249 throw new Error("initializeWasm() must be awaited first!");
32251 const nativeResponseValue = wasm.TS_SiPrefix_milli();
32252 return nativeResponseValue;
32254 // enum LDKSiPrefix SiPrefix_micro(void);
32256 export function SiPrefix_micro(): SiPrefix {
32257 if(!isWasmInitialized) {
32258 throw new Error("initializeWasm() must be awaited first!");
32260 const nativeResponseValue = wasm.TS_SiPrefix_micro();
32261 return nativeResponseValue;
32263 // enum LDKSiPrefix SiPrefix_nano(void);
32265 export function SiPrefix_nano(): SiPrefix {
32266 if(!isWasmInitialized) {
32267 throw new Error("initializeWasm() must be awaited first!");
32269 const nativeResponseValue = wasm.TS_SiPrefix_nano();
32270 return nativeResponseValue;
32272 // enum LDKSiPrefix SiPrefix_pico(void);
32274 export function SiPrefix_pico(): SiPrefix {
32275 if(!isWasmInitialized) {
32276 throw new Error("initializeWasm() must be awaited first!");
32278 const nativeResponseValue = wasm.TS_SiPrefix_pico();
32279 return nativeResponseValue;
32281 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
32283 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
32284 if(!isWasmInitialized) {
32285 throw new Error("initializeWasm() must be awaited first!");
32287 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
32288 return nativeResponseValue;
32290 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
32292 export function SiPrefix_multiplier(this_arg: bigint): bigint {
32293 if(!isWasmInitialized) {
32294 throw new Error("initializeWasm() must be awaited first!");
32296 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
32297 return nativeResponseValue;
32299 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
32301 export function Currency_clone(orig: bigint): Currency {
32302 if(!isWasmInitialized) {
32303 throw new Error("initializeWasm() must be awaited first!");
32305 const nativeResponseValue = wasm.TS_Currency_clone(orig);
32306 return nativeResponseValue;
32308 // enum LDKCurrency Currency_bitcoin(void);
32310 export function Currency_bitcoin(): Currency {
32311 if(!isWasmInitialized) {
32312 throw new Error("initializeWasm() must be awaited first!");
32314 const nativeResponseValue = wasm.TS_Currency_bitcoin();
32315 return nativeResponseValue;
32317 // enum LDKCurrency Currency_bitcoin_testnet(void);
32319 export function Currency_bitcoin_testnet(): Currency {
32320 if(!isWasmInitialized) {
32321 throw new Error("initializeWasm() must be awaited first!");
32323 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
32324 return nativeResponseValue;
32326 // enum LDKCurrency Currency_regtest(void);
32328 export function Currency_regtest(): Currency {
32329 if(!isWasmInitialized) {
32330 throw new Error("initializeWasm() must be awaited first!");
32332 const nativeResponseValue = wasm.TS_Currency_regtest();
32333 return nativeResponseValue;
32335 // enum LDKCurrency Currency_simnet(void);
32337 export function Currency_simnet(): Currency {
32338 if(!isWasmInitialized) {
32339 throw new Error("initializeWasm() must be awaited first!");
32341 const nativeResponseValue = wasm.TS_Currency_simnet();
32342 return nativeResponseValue;
32344 // enum LDKCurrency Currency_signet(void);
32346 export function Currency_signet(): Currency {
32347 if(!isWasmInitialized) {
32348 throw new Error("initializeWasm() must be awaited first!");
32350 const nativeResponseValue = wasm.TS_Currency_signet();
32351 return nativeResponseValue;
32353 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
32355 export function Currency_hash(o: bigint): bigint {
32356 if(!isWasmInitialized) {
32357 throw new Error("initializeWasm() must be awaited first!");
32359 const nativeResponseValue = wasm.TS_Currency_hash(o);
32360 return nativeResponseValue;
32362 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
32364 export function Currency_eq(a: bigint, b: bigint): boolean {
32365 if(!isWasmInitialized) {
32366 throw new Error("initializeWasm() must be awaited first!");
32368 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
32369 return nativeResponseValue;
32371 // void Sha256_free(struct LDKSha256 this_obj);
32373 export function Sha256_free(this_obj: bigint): void {
32374 if(!isWasmInitialized) {
32375 throw new Error("initializeWasm() must be awaited first!");
32377 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
32378 // debug statements here
32380 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
32382 export function Sha256_clone_ptr(arg: bigint): bigint {
32383 if(!isWasmInitialized) {
32384 throw new Error("initializeWasm() must be awaited first!");
32386 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
32387 return nativeResponseValue;
32389 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
32391 export function Sha256_clone(orig: bigint): bigint {
32392 if(!isWasmInitialized) {
32393 throw new Error("initializeWasm() must be awaited first!");
32395 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
32396 return nativeResponseValue;
32398 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
32400 export function Sha256_hash(o: bigint): bigint {
32401 if(!isWasmInitialized) {
32402 throw new Error("initializeWasm() must be awaited first!");
32404 const nativeResponseValue = wasm.TS_Sha256_hash(o);
32405 return nativeResponseValue;
32407 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
32409 export function Sha256_eq(a: bigint, b: bigint): boolean {
32410 if(!isWasmInitialized) {
32411 throw new Error("initializeWasm() must be awaited first!");
32413 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
32414 return nativeResponseValue;
32416 // void Description_free(struct LDKDescription this_obj);
32418 export function Description_free(this_obj: bigint): void {
32419 if(!isWasmInitialized) {
32420 throw new Error("initializeWasm() must be awaited first!");
32422 const nativeResponseValue = wasm.TS_Description_free(this_obj);
32423 // debug statements here
32425 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
32427 export function Description_clone_ptr(arg: bigint): bigint {
32428 if(!isWasmInitialized) {
32429 throw new Error("initializeWasm() must be awaited first!");
32431 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
32432 return nativeResponseValue;
32434 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
32436 export function Description_clone(orig: bigint): bigint {
32437 if(!isWasmInitialized) {
32438 throw new Error("initializeWasm() must be awaited first!");
32440 const nativeResponseValue = wasm.TS_Description_clone(orig);
32441 return nativeResponseValue;
32443 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
32445 export function Description_hash(o: bigint): bigint {
32446 if(!isWasmInitialized) {
32447 throw new Error("initializeWasm() must be awaited first!");
32449 const nativeResponseValue = wasm.TS_Description_hash(o);
32450 return nativeResponseValue;
32452 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
32454 export function Description_eq(a: bigint, b: bigint): boolean {
32455 if(!isWasmInitialized) {
32456 throw new Error("initializeWasm() must be awaited first!");
32458 const nativeResponseValue = wasm.TS_Description_eq(a, b);
32459 return nativeResponseValue;
32461 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
32463 export function PayeePubKey_free(this_obj: bigint): void {
32464 if(!isWasmInitialized) {
32465 throw new Error("initializeWasm() must be awaited first!");
32467 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
32468 // debug statements here
32470 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
32472 export function PayeePubKey_get_a(this_ptr: bigint): number {
32473 if(!isWasmInitialized) {
32474 throw new Error("initializeWasm() must be awaited first!");
32476 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
32477 return nativeResponseValue;
32479 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32481 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
32482 if(!isWasmInitialized) {
32483 throw new Error("initializeWasm() must be awaited first!");
32485 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
32486 // debug statements here
32488 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
32490 export function PayeePubKey_new(a_arg: number): bigint {
32491 if(!isWasmInitialized) {
32492 throw new Error("initializeWasm() must be awaited first!");
32494 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
32495 return nativeResponseValue;
32497 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
32499 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
32500 if(!isWasmInitialized) {
32501 throw new Error("initializeWasm() must be awaited first!");
32503 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
32504 return nativeResponseValue;
32506 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
32508 export function PayeePubKey_clone(orig: bigint): bigint {
32509 if(!isWasmInitialized) {
32510 throw new Error("initializeWasm() must be awaited first!");
32512 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
32513 return nativeResponseValue;
32515 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
32517 export function PayeePubKey_hash(o: bigint): bigint {
32518 if(!isWasmInitialized) {
32519 throw new Error("initializeWasm() must be awaited first!");
32521 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
32522 return nativeResponseValue;
32524 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
32526 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
32527 if(!isWasmInitialized) {
32528 throw new Error("initializeWasm() must be awaited first!");
32530 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
32531 return nativeResponseValue;
32533 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
32535 export function ExpiryTime_free(this_obj: bigint): void {
32536 if(!isWasmInitialized) {
32537 throw new Error("initializeWasm() must be awaited first!");
32539 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
32540 // debug statements here
32542 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
32544 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
32545 if(!isWasmInitialized) {
32546 throw new Error("initializeWasm() must be awaited first!");
32548 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
32549 return nativeResponseValue;
32551 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
32553 export function ExpiryTime_clone(orig: bigint): bigint {
32554 if(!isWasmInitialized) {
32555 throw new Error("initializeWasm() must be awaited first!");
32557 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
32558 return nativeResponseValue;
32560 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
32562 export function ExpiryTime_hash(o: bigint): bigint {
32563 if(!isWasmInitialized) {
32564 throw new Error("initializeWasm() must be awaited first!");
32566 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
32567 return nativeResponseValue;
32569 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
32571 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
32572 if(!isWasmInitialized) {
32573 throw new Error("initializeWasm() must be awaited first!");
32575 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
32576 return nativeResponseValue;
32578 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
32580 export function MinFinalCltvExpiry_free(this_obj: bigint): void {
32581 if(!isWasmInitialized) {
32582 throw new Error("initializeWasm() must be awaited first!");
32584 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
32585 // debug statements here
32587 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
32589 export function MinFinalCltvExpiry_get_a(this_ptr: bigint): bigint {
32590 if(!isWasmInitialized) {
32591 throw new Error("initializeWasm() must be awaited first!");
32593 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
32594 return nativeResponseValue;
32596 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
32598 export function MinFinalCltvExpiry_set_a(this_ptr: bigint, val: bigint): void {
32599 if(!isWasmInitialized) {
32600 throw new Error("initializeWasm() must be awaited first!");
32602 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
32603 // debug statements here
32605 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
32607 export function MinFinalCltvExpiry_new(a_arg: bigint): bigint {
32608 if(!isWasmInitialized) {
32609 throw new Error("initializeWasm() must be awaited first!");
32611 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
32612 return nativeResponseValue;
32614 // uint64_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
32616 export function MinFinalCltvExpiry_clone_ptr(arg: bigint): bigint {
32617 if(!isWasmInitialized) {
32618 throw new Error("initializeWasm() must be awaited first!");
32620 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
32621 return nativeResponseValue;
32623 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
32625 export function MinFinalCltvExpiry_clone(orig: bigint): bigint {
32626 if(!isWasmInitialized) {
32627 throw new Error("initializeWasm() must be awaited first!");
32629 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
32630 return nativeResponseValue;
32632 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
32634 export function MinFinalCltvExpiry_hash(o: bigint): bigint {
32635 if(!isWasmInitialized) {
32636 throw new Error("initializeWasm() must be awaited first!");
32638 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
32639 return nativeResponseValue;
32641 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
32643 export function MinFinalCltvExpiry_eq(a: bigint, b: bigint): boolean {
32644 if(!isWasmInitialized) {
32645 throw new Error("initializeWasm() must be awaited first!");
32647 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
32648 return nativeResponseValue;
32650 // void Fallback_free(struct LDKFallback this_ptr);
32652 export function Fallback_free(this_ptr: bigint): void {
32653 if(!isWasmInitialized) {
32654 throw new Error("initializeWasm() must be awaited first!");
32656 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
32657 // debug statements here
32659 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
32661 export function Fallback_clone_ptr(arg: bigint): bigint {
32662 if(!isWasmInitialized) {
32663 throw new Error("initializeWasm() must be awaited first!");
32665 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
32666 return nativeResponseValue;
32668 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
32670 export function Fallback_clone(orig: bigint): bigint {
32671 if(!isWasmInitialized) {
32672 throw new Error("initializeWasm() must be awaited first!");
32674 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
32675 return nativeResponseValue;
32677 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
32679 export function Fallback_seg_wit_program(version: number, program: number): bigint {
32680 if(!isWasmInitialized) {
32681 throw new Error("initializeWasm() must be awaited first!");
32683 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
32684 return nativeResponseValue;
32686 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
32688 export function Fallback_pub_key_hash(a: number): bigint {
32689 if(!isWasmInitialized) {
32690 throw new Error("initializeWasm() must be awaited first!");
32692 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
32693 return nativeResponseValue;
32695 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
32697 export function Fallback_script_hash(a: number): bigint {
32698 if(!isWasmInitialized) {
32699 throw new Error("initializeWasm() must be awaited first!");
32701 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
32702 return nativeResponseValue;
32704 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
32706 export function Fallback_hash(o: bigint): bigint {
32707 if(!isWasmInitialized) {
32708 throw new Error("initializeWasm() must be awaited first!");
32710 const nativeResponseValue = wasm.TS_Fallback_hash(o);
32711 return nativeResponseValue;
32713 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
32715 export function Fallback_eq(a: bigint, b: bigint): boolean {
32716 if(!isWasmInitialized) {
32717 throw new Error("initializeWasm() must be awaited first!");
32719 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
32720 return nativeResponseValue;
32722 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
32724 export function InvoiceSignature_free(this_obj: bigint): void {
32725 if(!isWasmInitialized) {
32726 throw new Error("initializeWasm() must be awaited first!");
32728 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
32729 // debug statements here
32731 // uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
32733 export function InvoiceSignature_clone_ptr(arg: bigint): bigint {
32734 if(!isWasmInitialized) {
32735 throw new Error("initializeWasm() must be awaited first!");
32737 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
32738 return nativeResponseValue;
32740 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
32742 export function InvoiceSignature_clone(orig: bigint): bigint {
32743 if(!isWasmInitialized) {
32744 throw new Error("initializeWasm() must be awaited first!");
32746 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
32747 return nativeResponseValue;
32749 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
32751 export function InvoiceSignature_eq(a: bigint, b: bigint): boolean {
32752 if(!isWasmInitialized) {
32753 throw new Error("initializeWasm() must be awaited first!");
32755 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
32756 return nativeResponseValue;
32758 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
32760 export function PrivateRoute_free(this_obj: bigint): void {
32761 if(!isWasmInitialized) {
32762 throw new Error("initializeWasm() must be awaited first!");
32764 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
32765 // debug statements here
32767 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
32769 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
32770 if(!isWasmInitialized) {
32771 throw new Error("initializeWasm() must be awaited first!");
32773 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
32774 return nativeResponseValue;
32776 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
32778 export function PrivateRoute_clone(orig: bigint): bigint {
32779 if(!isWasmInitialized) {
32780 throw new Error("initializeWasm() must be awaited first!");
32782 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
32783 return nativeResponseValue;
32785 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
32787 export function PrivateRoute_hash(o: bigint): bigint {
32788 if(!isWasmInitialized) {
32789 throw new Error("initializeWasm() must be awaited first!");
32791 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
32792 return nativeResponseValue;
32794 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
32796 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
32797 if(!isWasmInitialized) {
32798 throw new Error("initializeWasm() must be awaited first!");
32800 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
32801 return nativeResponseValue;
32803 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
32805 export function SignedRawInvoice_into_parts(this_arg: bigint): bigint {
32806 if(!isWasmInitialized) {
32807 throw new Error("initializeWasm() must be awaited first!");
32809 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
32810 return nativeResponseValue;
32812 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32814 export function SignedRawInvoice_raw_invoice(this_arg: bigint): bigint {
32815 if(!isWasmInitialized) {
32816 throw new Error("initializeWasm() must be awaited first!");
32818 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
32819 return nativeResponseValue;
32821 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
32823 export function SignedRawInvoice_hash(this_arg: bigint): number {
32824 if(!isWasmInitialized) {
32825 throw new Error("initializeWasm() must be awaited first!");
32827 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
32828 return nativeResponseValue;
32830 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32832 export function SignedRawInvoice_signature(this_arg: bigint): bigint {
32833 if(!isWasmInitialized) {
32834 throw new Error("initializeWasm() must be awaited first!");
32836 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
32837 return nativeResponseValue;
32839 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32841 export function SignedRawInvoice_recover_payee_pub_key(this_arg: bigint): bigint {
32842 if(!isWasmInitialized) {
32843 throw new Error("initializeWasm() must be awaited first!");
32845 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
32846 return nativeResponseValue;
32848 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32850 export function SignedRawInvoice_check_signature(this_arg: bigint): boolean {
32851 if(!isWasmInitialized) {
32852 throw new Error("initializeWasm() must be awaited first!");
32854 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
32855 return nativeResponseValue;
32857 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32859 export function RawInvoice_hash(this_arg: bigint): number {
32860 if(!isWasmInitialized) {
32861 throw new Error("initializeWasm() must be awaited first!");
32863 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
32864 return nativeResponseValue;
32866 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32868 export function RawInvoice_payment_hash(this_arg: bigint): bigint {
32869 if(!isWasmInitialized) {
32870 throw new Error("initializeWasm() must be awaited first!");
32872 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
32873 return nativeResponseValue;
32875 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32877 export function RawInvoice_description(this_arg: bigint): bigint {
32878 if(!isWasmInitialized) {
32879 throw new Error("initializeWasm() must be awaited first!");
32881 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
32882 return nativeResponseValue;
32884 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32886 export function RawInvoice_payee_pub_key(this_arg: bigint): bigint {
32887 if(!isWasmInitialized) {
32888 throw new Error("initializeWasm() must be awaited first!");
32890 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
32891 return nativeResponseValue;
32893 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32895 export function RawInvoice_description_hash(this_arg: bigint): bigint {
32896 if(!isWasmInitialized) {
32897 throw new Error("initializeWasm() must be awaited first!");
32899 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
32900 return nativeResponseValue;
32902 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32904 export function RawInvoice_expiry_time(this_arg: bigint): bigint {
32905 if(!isWasmInitialized) {
32906 throw new Error("initializeWasm() must be awaited first!");
32908 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
32909 return nativeResponseValue;
32911 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32913 export function RawInvoice_min_final_cltv_expiry(this_arg: bigint): bigint {
32914 if(!isWasmInitialized) {
32915 throw new Error("initializeWasm() must be awaited first!");
32917 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
32918 return nativeResponseValue;
32920 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32922 export function RawInvoice_payment_secret(this_arg: bigint): number {
32923 if(!isWasmInitialized) {
32924 throw new Error("initializeWasm() must be awaited first!");
32926 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
32927 return nativeResponseValue;
32929 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32931 export function RawInvoice_features(this_arg: bigint): bigint {
32932 if(!isWasmInitialized) {
32933 throw new Error("initializeWasm() must be awaited first!");
32935 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
32936 return nativeResponseValue;
32938 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32940 export function RawInvoice_private_routes(this_arg: bigint): number {
32941 if(!isWasmInitialized) {
32942 throw new Error("initializeWasm() must be awaited first!");
32944 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
32945 return nativeResponseValue;
32947 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32949 export function RawInvoice_amount_pico_btc(this_arg: bigint): bigint {
32950 if(!isWasmInitialized) {
32951 throw new Error("initializeWasm() must be awaited first!");
32953 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
32954 return nativeResponseValue;
32956 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32958 export function RawInvoice_currency(this_arg: bigint): Currency {
32959 if(!isWasmInitialized) {
32960 throw new Error("initializeWasm() must be awaited first!");
32962 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
32963 return nativeResponseValue;
32965 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
32967 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
32968 if(!isWasmInitialized) {
32969 throw new Error("initializeWasm() must be awaited first!");
32971 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
32972 return nativeResponseValue;
32974 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
32976 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
32977 if(!isWasmInitialized) {
32978 throw new Error("initializeWasm() must be awaited first!");
32980 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
32981 return nativeResponseValue;
32983 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32985 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
32986 if(!isWasmInitialized) {
32987 throw new Error("initializeWasm() must be awaited first!");
32989 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
32990 return nativeResponseValue;
32992 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32994 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
32995 if(!isWasmInitialized) {
32996 throw new Error("initializeWasm() must be awaited first!");
32998 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
32999 return nativeResponseValue;
33001 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
33003 export function Invoice_into_signed_raw(this_arg: bigint): bigint {
33004 if(!isWasmInitialized) {
33005 throw new Error("initializeWasm() must be awaited first!");
33007 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
33008 return nativeResponseValue;
33010 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
33012 export function Invoice_check_signature(this_arg: bigint): bigint {
33013 if(!isWasmInitialized) {
33014 throw new Error("initializeWasm() must be awaited first!");
33016 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
33017 return nativeResponseValue;
33019 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
33021 export function Invoice_from_signed(signed_invoice: bigint): bigint {
33022 if(!isWasmInitialized) {
33023 throw new Error("initializeWasm() must be awaited first!");
33025 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
33026 return nativeResponseValue;
33028 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
33030 export function Invoice_duration_since_epoch(this_arg: bigint): bigint {
33031 if(!isWasmInitialized) {
33032 throw new Error("initializeWasm() must be awaited first!");
33034 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
33035 return nativeResponseValue;
33037 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
33039 export function Invoice_payment_hash(this_arg: bigint): number {
33040 if(!isWasmInitialized) {
33041 throw new Error("initializeWasm() must be awaited first!");
33043 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
33044 return nativeResponseValue;
33046 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
33048 export function Invoice_payee_pub_key(this_arg: bigint): number {
33049 if(!isWasmInitialized) {
33050 throw new Error("initializeWasm() must be awaited first!");
33052 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
33053 return nativeResponseValue;
33055 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
33057 export function Invoice_payment_secret(this_arg: bigint): number {
33058 if(!isWasmInitialized) {
33059 throw new Error("initializeWasm() must be awaited first!");
33061 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
33062 return nativeResponseValue;
33064 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
33066 export function Invoice_features(this_arg: bigint): bigint {
33067 if(!isWasmInitialized) {
33068 throw new Error("initializeWasm() must be awaited first!");
33070 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
33071 return nativeResponseValue;
33073 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
33075 export function Invoice_recover_payee_pub_key(this_arg: bigint): number {
33076 if(!isWasmInitialized) {
33077 throw new Error("initializeWasm() must be awaited first!");
33079 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
33080 return nativeResponseValue;
33082 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
33084 export function Invoice_expiry_time(this_arg: bigint): bigint {
33085 if(!isWasmInitialized) {
33086 throw new Error("initializeWasm() must be awaited first!");
33088 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
33089 return nativeResponseValue;
33091 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
33093 export function Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
33094 if(!isWasmInitialized) {
33095 throw new Error("initializeWasm() must be awaited first!");
33097 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
33098 return nativeResponseValue;
33100 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
33102 export function Invoice_min_final_cltv_expiry(this_arg: bigint): bigint {
33103 if(!isWasmInitialized) {
33104 throw new Error("initializeWasm() must be awaited first!");
33106 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
33107 return nativeResponseValue;
33109 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
33111 export function Invoice_private_routes(this_arg: bigint): number {
33112 if(!isWasmInitialized) {
33113 throw new Error("initializeWasm() must be awaited first!");
33115 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
33116 return nativeResponseValue;
33118 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
33120 export function Invoice_route_hints(this_arg: bigint): number {
33121 if(!isWasmInitialized) {
33122 throw new Error("initializeWasm() must be awaited first!");
33124 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
33125 return nativeResponseValue;
33127 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
33129 export function Invoice_currency(this_arg: bigint): Currency {
33130 if(!isWasmInitialized) {
33131 throw new Error("initializeWasm() must be awaited first!");
33133 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
33134 return nativeResponseValue;
33136 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
33138 export function Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
33139 if(!isWasmInitialized) {
33140 throw new Error("initializeWasm() must be awaited first!");
33142 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
33143 return nativeResponseValue;
33145 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
33147 export function Description_new(description: number): bigint {
33148 if(!isWasmInitialized) {
33149 throw new Error("initializeWasm() must be awaited first!");
33151 const nativeResponseValue = wasm.TS_Description_new(description);
33152 return nativeResponseValue;
33154 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
33156 export function Description_into_inner(this_arg: bigint): number {
33157 if(!isWasmInitialized) {
33158 throw new Error("initializeWasm() must be awaited first!");
33160 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
33161 return nativeResponseValue;
33163 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
33165 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
33166 if(!isWasmInitialized) {
33167 throw new Error("initializeWasm() must be awaited first!");
33169 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
33170 return nativeResponseValue;
33172 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
33174 export function ExpiryTime_from_duration(duration: bigint): bigint {
33175 if(!isWasmInitialized) {
33176 throw new Error("initializeWasm() must be awaited first!");
33178 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
33179 return nativeResponseValue;
33181 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
33183 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
33184 if(!isWasmInitialized) {
33185 throw new Error("initializeWasm() must be awaited first!");
33187 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
33188 return nativeResponseValue;
33190 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
33192 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
33193 if(!isWasmInitialized) {
33194 throw new Error("initializeWasm() must be awaited first!");
33196 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
33197 return nativeResponseValue;
33199 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
33201 export function PrivateRoute_new(hops: bigint): bigint {
33202 if(!isWasmInitialized) {
33203 throw new Error("initializeWasm() must be awaited first!");
33205 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
33206 return nativeResponseValue;
33208 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
33210 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
33211 if(!isWasmInitialized) {
33212 throw new Error("initializeWasm() must be awaited first!");
33214 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
33215 return nativeResponseValue;
33217 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
33219 export function CreationError_clone(orig: bigint): CreationError {
33220 if(!isWasmInitialized) {
33221 throw new Error("initializeWasm() must be awaited first!");
33223 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
33224 return nativeResponseValue;
33226 // enum LDKCreationError CreationError_description_too_long(void);
33228 export function CreationError_description_too_long(): CreationError {
33229 if(!isWasmInitialized) {
33230 throw new Error("initializeWasm() must be awaited first!");
33232 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
33233 return nativeResponseValue;
33235 // enum LDKCreationError CreationError_route_too_long(void);
33237 export function CreationError_route_too_long(): CreationError {
33238 if(!isWasmInitialized) {
33239 throw new Error("initializeWasm() must be awaited first!");
33241 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
33242 return nativeResponseValue;
33244 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
33246 export function CreationError_timestamp_out_of_bounds(): CreationError {
33247 if(!isWasmInitialized) {
33248 throw new Error("initializeWasm() must be awaited first!");
33250 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
33251 return nativeResponseValue;
33253 // enum LDKCreationError CreationError_invalid_amount(void);
33255 export function CreationError_invalid_amount(): CreationError {
33256 if(!isWasmInitialized) {
33257 throw new Error("initializeWasm() must be awaited first!");
33259 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
33260 return nativeResponseValue;
33262 // enum LDKCreationError CreationError_missing_route_hints(void);
33264 export function CreationError_missing_route_hints(): CreationError {
33265 if(!isWasmInitialized) {
33266 throw new Error("initializeWasm() must be awaited first!");
33268 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
33269 return nativeResponseValue;
33271 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
33273 export function CreationError_eq(a: bigint, b: bigint): boolean {
33274 if(!isWasmInitialized) {
33275 throw new Error("initializeWasm() must be awaited first!");
33277 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
33278 return nativeResponseValue;
33280 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
33282 export function CreationError_to_str(o: bigint): number {
33283 if(!isWasmInitialized) {
33284 throw new Error("initializeWasm() must be awaited first!");
33286 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
33287 return nativeResponseValue;
33289 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
33291 export function SemanticError_clone(orig: bigint): SemanticError {
33292 if(!isWasmInitialized) {
33293 throw new Error("initializeWasm() must be awaited first!");
33295 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
33296 return nativeResponseValue;
33298 // enum LDKSemanticError SemanticError_no_payment_hash(void);
33300 export function SemanticError_no_payment_hash(): SemanticError {
33301 if(!isWasmInitialized) {
33302 throw new Error("initializeWasm() must be awaited first!");
33304 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
33305 return nativeResponseValue;
33307 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
33309 export function SemanticError_multiple_payment_hashes(): SemanticError {
33310 if(!isWasmInitialized) {
33311 throw new Error("initializeWasm() must be awaited first!");
33313 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
33314 return nativeResponseValue;
33316 // enum LDKSemanticError SemanticError_no_description(void);
33318 export function SemanticError_no_description(): SemanticError {
33319 if(!isWasmInitialized) {
33320 throw new Error("initializeWasm() must be awaited first!");
33322 const nativeResponseValue = wasm.TS_SemanticError_no_description();
33323 return nativeResponseValue;
33325 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
33327 export function SemanticError_multiple_descriptions(): SemanticError {
33328 if(!isWasmInitialized) {
33329 throw new Error("initializeWasm() must be awaited first!");
33331 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
33332 return nativeResponseValue;
33334 // enum LDKSemanticError SemanticError_no_payment_secret(void);
33336 export function SemanticError_no_payment_secret(): SemanticError {
33337 if(!isWasmInitialized) {
33338 throw new Error("initializeWasm() must be awaited first!");
33340 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
33341 return nativeResponseValue;
33343 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
33345 export function SemanticError_multiple_payment_secrets(): SemanticError {
33346 if(!isWasmInitialized) {
33347 throw new Error("initializeWasm() must be awaited first!");
33349 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
33350 return nativeResponseValue;
33352 // enum LDKSemanticError SemanticError_invalid_features(void);
33354 export function SemanticError_invalid_features(): SemanticError {
33355 if(!isWasmInitialized) {
33356 throw new Error("initializeWasm() must be awaited first!");
33358 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
33359 return nativeResponseValue;
33361 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
33363 export function SemanticError_invalid_recovery_id(): SemanticError {
33364 if(!isWasmInitialized) {
33365 throw new Error("initializeWasm() must be awaited first!");
33367 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
33368 return nativeResponseValue;
33370 // enum LDKSemanticError SemanticError_invalid_signature(void);
33372 export function SemanticError_invalid_signature(): SemanticError {
33373 if(!isWasmInitialized) {
33374 throw new Error("initializeWasm() must be awaited first!");
33376 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
33377 return nativeResponseValue;
33379 // enum LDKSemanticError SemanticError_imprecise_amount(void);
33381 export function SemanticError_imprecise_amount(): SemanticError {
33382 if(!isWasmInitialized) {
33383 throw new Error("initializeWasm() must be awaited first!");
33385 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
33386 return nativeResponseValue;
33388 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
33390 export function SemanticError_eq(a: bigint, b: bigint): boolean {
33391 if(!isWasmInitialized) {
33392 throw new Error("initializeWasm() must be awaited first!");
33394 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
33395 return nativeResponseValue;
33397 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
33399 export function SemanticError_to_str(o: bigint): number {
33400 if(!isWasmInitialized) {
33401 throw new Error("initializeWasm() must be awaited first!");
33403 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
33404 return nativeResponseValue;
33406 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
33408 export function SignOrCreationError_free(this_ptr: bigint): void {
33409 if(!isWasmInitialized) {
33410 throw new Error("initializeWasm() must be awaited first!");
33412 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
33413 // debug statements here
33415 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
33417 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
33418 if(!isWasmInitialized) {
33419 throw new Error("initializeWasm() must be awaited first!");
33421 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
33422 return nativeResponseValue;
33424 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
33426 export function SignOrCreationError_clone(orig: bigint): bigint {
33427 if(!isWasmInitialized) {
33428 throw new Error("initializeWasm() must be awaited first!");
33430 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
33431 return nativeResponseValue;
33433 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
33435 export function SignOrCreationError_sign_error(): bigint {
33436 if(!isWasmInitialized) {
33437 throw new Error("initializeWasm() must be awaited first!");
33439 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
33440 return nativeResponseValue;
33442 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
33444 export function SignOrCreationError_creation_error(a: CreationError): bigint {
33445 if(!isWasmInitialized) {
33446 throw new Error("initializeWasm() must be awaited first!");
33448 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
33449 return nativeResponseValue;
33451 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
33453 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
33454 if(!isWasmInitialized) {
33455 throw new Error("initializeWasm() must be awaited first!");
33457 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
33458 return nativeResponseValue;
33460 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
33462 export function SignOrCreationError_to_str(o: bigint): number {
33463 if(!isWasmInitialized) {
33464 throw new Error("initializeWasm() must be awaited first!");
33466 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
33467 return nativeResponseValue;
33469 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
33471 export function InvoicePayer_free(this_obj: bigint): void {
33472 if(!isWasmInitialized) {
33473 throw new Error("initializeWasm() must be awaited first!");
33475 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
33476 // debug statements here
33478 // void Payer_free(struct LDKPayer this_ptr);
33480 export function Payer_free(this_ptr: bigint): void {
33481 if(!isWasmInitialized) {
33482 throw new Error("initializeWasm() must be awaited first!");
33484 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
33485 // debug statements here
33487 // void Router_free(struct LDKRouter this_ptr);
33489 export function Router_free(this_ptr: bigint): void {
33490 if(!isWasmInitialized) {
33491 throw new Error("initializeWasm() must be awaited first!");
33493 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
33494 // debug statements here
33496 // void Retry_free(struct LDKRetry this_ptr);
33498 export function Retry_free(this_ptr: bigint): void {
33499 if(!isWasmInitialized) {
33500 throw new Error("initializeWasm() must be awaited first!");
33502 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
33503 // debug statements here
33505 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
33507 export function Retry_clone_ptr(arg: bigint): bigint {
33508 if(!isWasmInitialized) {
33509 throw new Error("initializeWasm() must be awaited first!");
33511 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
33512 return nativeResponseValue;
33514 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
33516 export function Retry_clone(orig: bigint): bigint {
33517 if(!isWasmInitialized) {
33518 throw new Error("initializeWasm() must be awaited first!");
33520 const nativeResponseValue = wasm.TS_Retry_clone(orig);
33521 return nativeResponseValue;
33523 // struct LDKRetry Retry_attempts(uintptr_t a);
33525 export function Retry_attempts(a: number): bigint {
33526 if(!isWasmInitialized) {
33527 throw new Error("initializeWasm() must be awaited first!");
33529 const nativeResponseValue = wasm.TS_Retry_attempts(a);
33530 return nativeResponseValue;
33532 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
33534 export function Retry_eq(a: bigint, b: bigint): boolean {
33535 if(!isWasmInitialized) {
33536 throw new Error("initializeWasm() must be awaited first!");
33538 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
33539 return nativeResponseValue;
33541 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
33543 export function Retry_hash(o: bigint): bigint {
33544 if(!isWasmInitialized) {
33545 throw new Error("initializeWasm() must be awaited first!");
33547 const nativeResponseValue = wasm.TS_Retry_hash(o);
33548 return nativeResponseValue;
33550 // void PaymentError_free(struct LDKPaymentError this_ptr);
33552 export function PaymentError_free(this_ptr: bigint): void {
33553 if(!isWasmInitialized) {
33554 throw new Error("initializeWasm() must be awaited first!");
33556 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
33557 // debug statements here
33559 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
33561 export function PaymentError_clone_ptr(arg: bigint): bigint {
33562 if(!isWasmInitialized) {
33563 throw new Error("initializeWasm() must be awaited first!");
33565 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
33566 return nativeResponseValue;
33568 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
33570 export function PaymentError_clone(orig: bigint): bigint {
33571 if(!isWasmInitialized) {
33572 throw new Error("initializeWasm() must be awaited first!");
33574 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
33575 return nativeResponseValue;
33577 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
33579 export function PaymentError_invoice(a: number): bigint {
33580 if(!isWasmInitialized) {
33581 throw new Error("initializeWasm() must be awaited first!");
33583 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
33584 return nativeResponseValue;
33586 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
33588 export function PaymentError_routing(a: bigint): bigint {
33589 if(!isWasmInitialized) {
33590 throw new Error("initializeWasm() must be awaited first!");
33592 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
33593 return nativeResponseValue;
33595 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
33597 export function PaymentError_sending(a: bigint): bigint {
33598 if(!isWasmInitialized) {
33599 throw new Error("initializeWasm() must be awaited first!");
33601 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
33602 return nativeResponseValue;
33604 // MUST_USE_RES struct LDKInvoicePayer InvoicePayer_new(struct LDKPayer payer, struct LDKRouter router, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer, struct LDKLogger logger, struct LDKEventHandler event_handler, struct LDKRetry retry);
33606 export function InvoicePayer_new(payer: bigint, router: bigint, scorer: bigint, logger: bigint, event_handler: bigint, retry: bigint): bigint {
33607 if(!isWasmInitialized) {
33608 throw new Error("initializeWasm() must be awaited first!");
33610 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
33611 return nativeResponseValue;
33613 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
33615 export function InvoicePayer_pay_invoice(this_arg: bigint, invoice: bigint): bigint {
33616 if(!isWasmInitialized) {
33617 throw new Error("initializeWasm() must be awaited first!");
33619 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
33620 return nativeResponseValue;
33622 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_zero_value_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice, uint64_t amount_msats);
33624 export function InvoicePayer_pay_zero_value_invoice(this_arg: bigint, invoice: bigint, amount_msats: bigint): bigint {
33625 if(!isWasmInitialized) {
33626 throw new Error("initializeWasm() must be awaited first!");
33628 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
33629 return nativeResponseValue;
33631 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_pubkey(const struct LDKInvoicePayer *NONNULL_PTR this_arg, struct LDKPublicKey pubkey, struct LDKThirtyTwoBytes payment_preimage, uint64_t amount_msats, uint32_t final_cltv_expiry_delta);
33633 export function InvoicePayer_pay_pubkey(this_arg: bigint, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): bigint {
33634 if(!isWasmInitialized) {
33635 throw new Error("initializeWasm() must be awaited first!");
33637 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
33638 return nativeResponseValue;
33640 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
33642 export function InvoicePayer_remove_cached_payment(this_arg: bigint, payment_hash: number): void {
33643 if(!isWasmInitialized) {
33644 throw new Error("initializeWasm() must be awaited first!");
33646 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
33647 // debug statements here
33649 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
33651 export function InvoicePayer_as_EventHandler(this_arg: bigint): bigint {
33652 if(!isWasmInitialized) {
33653 throw new Error("initializeWasm() must be awaited first!");
33655 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
33656 return nativeResponseValue;
33658 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKSha256 description_hash, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
33660 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
33661 if(!isWasmInitialized) {
33662 throw new Error("initializeWasm() must be awaited first!");
33664 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs);
33665 return nativeResponseValue;
33667 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
33669 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, keys_manager: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): bigint {
33670 if(!isWasmInitialized) {
33671 throw new Error("initializeWasm() must be awaited first!");
33673 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs);
33674 return nativeResponseValue;
33676 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
33678 export function DefaultRouter_free(this_obj: bigint): void {
33679 if(!isWasmInitialized) {
33680 throw new Error("initializeWasm() must be awaited first!");
33682 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
33683 // debug statements here
33685 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
33687 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number): bigint {
33688 if(!isWasmInitialized) {
33689 throw new Error("initializeWasm() must be awaited first!");
33691 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
33692 return nativeResponseValue;
33694 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
33696 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
33697 if(!isWasmInitialized) {
33698 throw new Error("initializeWasm() must be awaited first!");
33700 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
33701 return nativeResponseValue;
33703 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
33705 export function ChannelManager_as_Payer(this_arg: bigint): bigint {
33706 if(!isWasmInitialized) {
33707 throw new Error("initializeWasm() must be awaited first!");
33709 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
33710 return nativeResponseValue;
33712 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
33714 export function SiPrefix_from_str(s: number): bigint {
33715 if(!isWasmInitialized) {
33716 throw new Error("initializeWasm() must be awaited first!");
33718 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
33719 return nativeResponseValue;
33721 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
33723 export function Invoice_from_str(s: number): bigint {
33724 if(!isWasmInitialized) {
33725 throw new Error("initializeWasm() must be awaited first!");
33727 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
33728 return nativeResponseValue;
33730 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
33732 export function SignedRawInvoice_from_str(s: number): bigint {
33733 if(!isWasmInitialized) {
33734 throw new Error("initializeWasm() must be awaited first!");
33736 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
33737 return nativeResponseValue;
33739 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
33741 export function ParseError_to_str(o: bigint): number {
33742 if(!isWasmInitialized) {
33743 throw new Error("initializeWasm() must be awaited first!");
33745 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
33746 return nativeResponseValue;
33748 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
33750 export function ParseOrSemanticError_to_str(o: bigint): number {
33751 if(!isWasmInitialized) {
33752 throw new Error("initializeWasm() must be awaited first!");
33754 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
33755 return nativeResponseValue;
33757 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
33759 export function Invoice_to_str(o: bigint): number {
33760 if(!isWasmInitialized) {
33761 throw new Error("initializeWasm() must be awaited first!");
33763 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
33764 return nativeResponseValue;
33766 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
33768 export function SignedRawInvoice_to_str(o: bigint): number {
33769 if(!isWasmInitialized) {
33770 throw new Error("initializeWasm() must be awaited first!");
33772 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
33773 return nativeResponseValue;
33775 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
33777 export function Currency_to_str(o: bigint): number {
33778 if(!isWasmInitialized) {
33779 throw new Error("initializeWasm() must be awaited first!");
33781 const nativeResponseValue = wasm.TS_Currency_to_str(o);
33782 return nativeResponseValue;
33784 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
33786 export function SiPrefix_to_str(o: bigint): number {
33787 if(!isWasmInitialized) {
33788 throw new Error("initializeWasm() must be awaited first!");
33790 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
33791 return nativeResponseValue;
33795 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) {
33796 const weak: WeakRef<object> = js_objs[obj_ptr];
33797 if (weak == null || weak == undefined) {
33798 console.error("Got function call on unknown/free'd JS object!");
33799 throw new Error("Got function call on unknown/free'd JS object!");
33801 const obj: object = weak.deref();
33802 if (obj == null || obj == undefined) {
33803 console.error("Got function call on GC'd JS object!");
33804 throw new Error("Got function call on GC'd JS object!");
33808 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
33809 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
33810 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
33811 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
33812 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
33813 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
33814 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
33815 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
33816 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
33817 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
33818 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
33819 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
33820 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
33821 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
33822 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
33823 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33824 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
33825 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
33826 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
33827 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
33828 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
33829 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
33830 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
33831 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
33832 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
33833 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
33834 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
33835 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
33836 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
33837 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
33838 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
33839 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33840 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
33841 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
33842 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
33843 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
33844 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
33845 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
33846 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
33847 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
33848 case 40: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
33849 case 41: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
33850 case 42: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33851 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
33852 case 44: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
33853 case 45: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
33854 case 46: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
33855 case 47: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
33856 case 48: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
33857 case 49: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
33858 case 50: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
33859 case 51: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
33860 case 52: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
33861 case 53: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
33862 case 54: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
33863 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
33864 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
33865 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
33866 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
33867 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
33868 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
33869 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
33870 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
33871 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
33872 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
33873 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
33874 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
33875 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
33876 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
33877 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
33878 case 70: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
33879 case 71: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33880 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
33881 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33882 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
33883 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
33884 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
33885 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33886 case 78: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
33887 case 79: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
33888 case 80: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33889 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
33890 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
33891 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
33892 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
33893 case 85: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
33894 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
33895 case 87: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
33896 case 88: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
33897 case 89: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
33898 case 90: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
33899 case 91: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
33900 case 92: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
33901 case 93: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
33902 case 94: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
33903 case 95: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
33904 case 96: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
33905 case 97: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
33906 case 98: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
33907 case 99: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
33909 console.error("Got unknown function call from C!");
33910 throw new Error("Got unknown function call from C!");
33912 if (fn == null || fn == undefined) {
33913 console.error("Got function call on incorrect JS object!");
33914 throw new Error("Got function call on incorrect JS object!");
33916 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
33917 if (ret === undefined || ret === null) return BigInt(0);
33918 return BigInt(ret);