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", "bbbbbb", "ubuuuu", "uubuuu"];
95 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
96 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
97 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
98 await finishInitializeWasm(wasmInstance);
102 export async function initializeWasmFetch(uri: string) {
103 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
104 const stream = fetch(uri);
105 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
106 await finishInitializeWasm(wasmInstance);
111 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
112 const arr = new Uint8Array(inputArray.length);
113 for (var i = 0; i < inputArray.length; i++) {
114 arr[i] = inputArray[i].getVal();
120 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
121 const arr = new Uint8Array(inputArray.length);
122 for (var i = 0; i < inputArray.length; i++) {
123 arr[i] = inputArray[i].getVal();
131 export function encodeUint8Array (inputArray: Uint8Array): number {
132 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
133 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
134 arrayLengthView[0] = BigInt(inputArray.length);
135 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
136 arrayMemoryView.set(inputArray);
137 return cArrayPointer;
140 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
141 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
142 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
143 arrayLengthView[0] = BigInt(inputArray.length);
144 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
145 arrayMemoryView.set(inputArray);
146 return cArrayPointer;
149 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
150 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
151 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
152 arrayMemoryView.set(inputArray, 1);
153 arrayMemoryView[0] = BigInt(inputArray.length);
154 return cArrayPointer;
158 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
159 if (arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
164 export function getArrayLength(arrayPointer: number): number {
165 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
166 const len = arraySizeViewer[0];
167 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
168 return Number(len % (2n ** 32n));
171 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
172 const arraySize = getArrayLength(arrayPointer);
173 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
174 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
175 // will free the underlying memory when it becomes unreachable instead of copying here.
176 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
177 const actualArray = actualArrayViewer.slice(0, arraySize);
179 wasm.TS_free(arrayPointer);
183 const decodeUint32Array = (arrayPointer: number, free = true) => {
184 const arraySize = getArrayLength(arrayPointer);
185 const actualArrayViewer = new Uint32Array(
186 wasm.memory.buffer, // value
187 arrayPointer + 8, // offset (ignoring length bytes)
188 arraySize // uint32 count
190 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
191 // will free the underlying memory when it becomes unreachable instead of copying here.
192 const actualArray = actualArrayViewer.slice(0, arraySize);
194 wasm.TS_free(arrayPointer);
199 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
200 const arraySize = getArrayLength(arrayPointer);
201 const actualArrayViewer = new BigUint64Array(
202 wasm.memory.buffer, // value
203 arrayPointer + 8, // offset (ignoring length bytes)
204 arraySize // uint32 count
206 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
207 // will free the underlying memory when it becomes unreachable instead of copying here.
208 const actualArray = new Array(arraySize);
209 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
211 wasm.TS_free(arrayPointer);
216 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
219 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
220 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
221 return actualArrayViewer[idx];
225 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
226 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
227 return actualArrayViewer[idx];
232 export function encodeString(str: string): number {
233 const charArray = new TextEncoder().encode(str);
234 return encodeUint8Array(charArray);
238 export function decodeString(stringPointer: number, free = true): string {
239 const arraySize = getArrayLength(stringPointer);
240 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
241 const result = new TextDecoder("utf-8").decode(memoryView);
244 wasm.TS_free(stringPointer);
250 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
251 /* @internal */ export function debugPrintRemainingAllocs() { }
254 * An error when accessing the chain via [`Access`].
256 export enum AccessError {
258 * The requested chain is unknown.
260 LDKAccessError_UnknownChain,
262 * The requested transaction doesn't exist or hasn't confirmed.
264 LDKAccessError_UnknownTx,
269 * An enum which can either contain a or not
271 export enum COption_NoneZ {
273 * When we're in this state, this COption_NoneZ contains a
275 LDKCOption_NoneZ_Some,
277 * When we're in this state, this COption_NoneZ contains nothing
279 LDKCOption_NoneZ_None,
284 * An error enum representing a failure to persist a channel monitor update.
286 export enum ChannelMonitorUpdateErr {
288 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
289 our state failed, but is expected to succeed at some point in the future).
291 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
292 submitting new commitment transactions to the counterparty. Once the update(s) that failed
293 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
294 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
297 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
298 you return a TemporaryFailure you must ensure that it is written to disk safely before
299 writing out the latest ChannelManager state.
301 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
302 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
303 to claim it on this channel) and those updates must be applied wherever they can be. At
304 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
305 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
306 the channel which would invalidate previous ChannelMonitors are not made when a channel has
309 Note that even if updates made after TemporaryFailure succeed you must still provide a
310 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
311 normal channel operation. Note that this is normally generated through a call to
312 [`ChainMonitor::channel_monitor_updated`].
314 Note that the update being processed here will not be replayed for you when you return a
315 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
316 you must store the update itself on your own local disk prior to returning a
317 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
318 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
321 For deployments where a copy of ChannelMonitors and other local state are backed up in a
322 remote location (with local copies persisted immediately), it is anticipated that all
323 updates will return TemporaryFailure until the remote copies could be updated.
325 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
327 LDKChannelMonitorUpdateErr_TemporaryFailure,
329 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
330 different watchtower and cannot update with all watchtowers that were previously informed
333 At reception of this error, ChannelManager will force-close the channel and return at
334 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
335 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
336 update must be rejected.
338 This failure may also signal a failure to update the local persisted copy of one of
339 the channel monitor instance.
341 Note that even when you fail a holder commitment transaction update, you must store the
342 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
343 broadcasts it (e.g distributed channel-monitor deployment)
345 In case of distributed watchtowers deployment, the new version must be written to disk, as
346 state may have been stored but rejected due to a block forcing a commitment broadcast. This
347 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
348 lagging behind on block processing.
350 LDKChannelMonitorUpdateErr_PermanentFailure,
355 * An enum that represents the speed at which we want a transaction to confirm used for feerate
358 export enum ConfirmationTarget {
360 * We are happy with this transaction confirming slowly when feerate drops some.
362 LDKConfirmationTarget_Background,
364 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
366 LDKConfirmationTarget_Normal,
368 * We'd like this transaction to confirm in the next few blocks.
370 LDKConfirmationTarget_HighPriority,
375 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
377 export enum CreationError {
379 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
381 LDKCreationError_DescriptionTooLong,
383 * The specified route has too many hops and can't be encoded
385 LDKCreationError_RouteTooLong,
387 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
389 LDKCreationError_TimestampOutOfBounds,
391 * The supplied millisatoshi amount was greater than the total bitcoin supply.
393 LDKCreationError_InvalidAmount,
395 * Route hints were required for this invoice and were missing. Applies to
398 [phantom invoices]: crate::utils::create_phantom_invoice
400 LDKCreationError_MissingRouteHints,
405 * Enum representing the crypto currencies (or networks) supported by this library
407 export enum Currency {
415 LDKCurrency_BitcoinTestnet,
432 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
434 export enum IOError {
436 LDKIOError_PermissionDenied,
437 LDKIOError_ConnectionRefused,
438 LDKIOError_ConnectionReset,
439 LDKIOError_ConnectionAborted,
440 LDKIOError_NotConnected,
441 LDKIOError_AddrInUse,
442 LDKIOError_AddrNotAvailable,
443 LDKIOError_BrokenPipe,
444 LDKIOError_AlreadyExists,
445 LDKIOError_WouldBlock,
446 LDKIOError_InvalidInput,
447 LDKIOError_InvalidData,
449 LDKIOError_WriteZero,
450 LDKIOError_Interrupted,
452 LDKIOError_UnexpectedEof,
457 * An enum representing the available verbosity levels of the logger.
461 * Designates extremely verbose information, including gossip-induced messages
465 * Designates very low priority, often extremely verbose, information
469 * Designates lower priority information
473 * Designates useful information
477 * Designates hazardous situations
481 * Designates very serious errors
488 * An enum representing the possible Bitcoin or test networks which we can run on
490 export enum Network {
492 * The main Bitcoin blockchain.
496 * The testnet3 blockchain.
500 * A local test blockchain.
504 * A blockchain on which blocks are signed instead of mined.
511 * Specifies the recipient of an invoice, to indicate to [`KeysInterface::sign_invoice`] what node
512 * secret key should be used to sign the invoice.
514 export enum Recipient {
516 * The invoice should be signed with the local node secret key.
520 * The invoice should be signed with the phantom node secret key. This secret key must be the
521 same for all nodes participating in the [phantom node payment].
523 [phantom node payment]: PhantomKeysManager
525 LDKRecipient_PhantomNode,
530 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
532 export enum Secp256k1Error {
534 * Signature failed verification
536 LDKSecp256k1Error_IncorrectSignature,
538 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
540 LDKSecp256k1Error_InvalidMessage,
544 LDKSecp256k1Error_InvalidPublicKey,
548 LDKSecp256k1Error_InvalidSignature,
552 LDKSecp256k1Error_InvalidSecretKey,
556 LDKSecp256k1Error_InvalidSharedSecret,
560 LDKSecp256k1Error_InvalidRecoveryId,
562 * Invalid tweak for add_assign or mul_assign
564 LDKSecp256k1Error_InvalidTweak,
566 * Didn't pass enough memory to context creation with preallocated memory
568 LDKSecp256k1Error_NotEnoughMemory,
570 * Bad set of public keys.
572 LDKSecp256k1Error_InvalidPublicKeySum,
574 * The only valid parity values are 0 or 1.
576 LDKSecp256k1Error_InvalidParityValue,
581 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
582 * requirements sections in BOLT #11
584 export enum SemanticError {
586 * The invoice is missing the mandatory payment hash
588 LDKSemanticError_NoPaymentHash,
590 * The invoice has multiple payment hashes which isn't allowed
592 LDKSemanticError_MultiplePaymentHashes,
594 * No description or description hash are part of the invoice
596 LDKSemanticError_NoDescription,
598 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
600 LDKSemanticError_MultipleDescriptions,
602 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
605 LDKSemanticError_NoPaymentSecret,
607 * The invoice contains multiple payment secrets
609 LDKSemanticError_MultiplePaymentSecrets,
611 * The invoice's features are invalid
613 LDKSemanticError_InvalidFeatures,
615 * The recovery id doesn't fit the signature/pub key
617 LDKSemanticError_InvalidRecoveryId,
619 * The invoice's signature is invalid
621 LDKSemanticError_InvalidSignature,
623 * The invoice's amount was not a whole number of millisatoshis
625 LDKSemanticError_ImpreciseAmount,
630 * SI prefixes for the human readable part
632 export enum SiPrefix {
652 export class LDKBech32Error {
653 protected constructor() {}
656 export function LDKBech32Error_ty_from_ptr(ptr: number): number {
657 if(!isWasmInitialized) {
658 throw new Error("initializeWasm() must be awaited first!");
660 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
661 return nativeResponseValue;
664 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: number): number {
665 if(!isWasmInitialized) {
666 throw new Error("initializeWasm() must be awaited first!");
668 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
669 return nativeResponseValue;
672 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: number): number {
673 if(!isWasmInitialized) {
674 throw new Error("initializeWasm() must be awaited first!");
676 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
677 return nativeResponseValue;
679 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
681 export function TxOut_get_script_pubkey(thing: number): number {
682 if(!isWasmInitialized) {
683 throw new Error("initializeWasm() must be awaited first!");
685 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
686 return nativeResponseValue;
688 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
690 export function TxOut_get_value(thing: number): bigint {
691 if(!isWasmInitialized) {
692 throw new Error("initializeWasm() must be awaited first!");
694 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
695 return nativeResponseValue;
697 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
699 export function CResult_NoneNoneZ_get_ok(owner: number): void {
700 if(!isWasmInitialized) {
701 throw new Error("initializeWasm() must be awaited first!");
703 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
704 // debug statements here
706 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
708 export function CResult_NoneNoneZ_get_err(owner: number): void {
709 if(!isWasmInitialized) {
710 throw new Error("initializeWasm() must be awaited first!");
712 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
713 // debug statements here
715 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
717 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
718 if(!isWasmInitialized) {
719 throw new Error("initializeWasm() must be awaited first!");
721 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
722 return nativeResponseValue;
724 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
726 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
727 if(!isWasmInitialized) {
728 throw new Error("initializeWasm() must be awaited first!");
730 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
731 return nativeResponseValue;
733 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
735 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
736 if(!isWasmInitialized) {
737 throw new Error("initializeWasm() must be awaited first!");
739 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
740 return nativeResponseValue;
742 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
744 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
745 if(!isWasmInitialized) {
746 throw new Error("initializeWasm() must be awaited first!");
748 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
749 return nativeResponseValue;
751 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
753 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
754 if(!isWasmInitialized) {
755 throw new Error("initializeWasm() must be awaited first!");
757 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
758 return nativeResponseValue;
760 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
762 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
763 if(!isWasmInitialized) {
764 throw new Error("initializeWasm() must be awaited first!");
766 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
767 return nativeResponseValue;
769 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
771 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
772 if(!isWasmInitialized) {
773 throw new Error("initializeWasm() must be awaited first!");
775 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
776 return nativeResponseValue;
778 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
780 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
781 if(!isWasmInitialized) {
782 throw new Error("initializeWasm() must be awaited first!");
784 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
785 return nativeResponseValue;
787 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
789 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
790 if(!isWasmInitialized) {
791 throw new Error("initializeWasm() must be awaited first!");
793 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
794 return nativeResponseValue;
796 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
798 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
799 if(!isWasmInitialized) {
800 throw new Error("initializeWasm() must be awaited first!");
802 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
803 return nativeResponseValue;
805 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
807 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
808 if(!isWasmInitialized) {
809 throw new Error("initializeWasm() must be awaited first!");
811 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
812 return nativeResponseValue;
814 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
816 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
817 if(!isWasmInitialized) {
818 throw new Error("initializeWasm() must be awaited first!");
820 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
821 return nativeResponseValue;
824 export class LDKCOption_u32Z {
825 protected constructor() {}
828 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
829 if(!isWasmInitialized) {
830 throw new Error("initializeWasm() must be awaited first!");
832 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
833 return nativeResponseValue;
836 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
837 if(!isWasmInitialized) {
838 throw new Error("initializeWasm() must be awaited first!");
840 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
841 return nativeResponseValue;
843 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
845 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
846 if(!isWasmInitialized) {
847 throw new Error("initializeWasm() must be awaited first!");
849 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
850 return nativeResponseValue;
852 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
854 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
855 if(!isWasmInitialized) {
856 throw new Error("initializeWasm() must be awaited first!");
858 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
859 return nativeResponseValue;
861 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
863 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
864 if(!isWasmInitialized) {
865 throw new Error("initializeWasm() must be awaited first!");
867 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
868 return nativeResponseValue;
870 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
872 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
873 if(!isWasmInitialized) {
874 throw new Error("initializeWasm() must be awaited first!");
876 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
877 return nativeResponseValue;
879 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
881 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
882 if(!isWasmInitialized) {
883 throw new Error("initializeWasm() must be awaited first!");
885 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
886 return nativeResponseValue;
888 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
890 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
891 if(!isWasmInitialized) {
892 throw new Error("initializeWasm() must be awaited first!");
894 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
895 return nativeResponseValue;
897 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
899 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
900 if(!isWasmInitialized) {
901 throw new Error("initializeWasm() must be awaited first!");
903 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
904 return nativeResponseValue;
906 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
908 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
909 if(!isWasmInitialized) {
910 throw new Error("initializeWasm() must be awaited first!");
912 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
913 return nativeResponseValue;
915 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
917 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
918 if(!isWasmInitialized) {
919 throw new Error("initializeWasm() must be awaited first!");
921 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
922 return nativeResponseValue;
924 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
926 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
927 if(!isWasmInitialized) {
928 throw new Error("initializeWasm() must be awaited first!");
930 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
931 return nativeResponseValue;
933 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
935 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
936 if(!isWasmInitialized) {
937 throw new Error("initializeWasm() must be awaited first!");
939 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
940 return nativeResponseValue;
942 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
944 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
945 if(!isWasmInitialized) {
946 throw new Error("initializeWasm() must be awaited first!");
948 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
949 // debug statements here
951 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
953 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
954 if(!isWasmInitialized) {
955 throw new Error("initializeWasm() must be awaited first!");
957 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
958 return nativeResponseValue;
960 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
962 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
963 if(!isWasmInitialized) {
964 throw new Error("initializeWasm() must be awaited first!");
966 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
967 return nativeResponseValue;
969 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
971 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
972 if(!isWasmInitialized) {
973 throw new Error("initializeWasm() must be awaited first!");
975 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
976 return nativeResponseValue;
978 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
980 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
981 if(!isWasmInitialized) {
982 throw new Error("initializeWasm() must be awaited first!");
984 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
985 // debug statements here
987 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
989 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
990 if(!isWasmInitialized) {
991 throw new Error("initializeWasm() must be awaited first!");
993 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
994 return nativeResponseValue;
996 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
998 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
999 if(!isWasmInitialized) {
1000 throw new Error("initializeWasm() must be awaited first!");
1002 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
1003 // debug statements here
1005 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1007 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
1008 if(!isWasmInitialized) {
1009 throw new Error("initializeWasm() must be awaited first!");
1011 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
1012 return nativeResponseValue;
1014 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
1016 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
1017 if(!isWasmInitialized) {
1018 throw new Error("initializeWasm() must be awaited first!");
1020 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1021 return nativeResponseValue;
1023 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1025 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
1026 if(!isWasmInitialized) {
1027 throw new Error("initializeWasm() must be awaited first!");
1029 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1030 return nativeResponseValue;
1032 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1034 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
1035 if(!isWasmInitialized) {
1036 throw new Error("initializeWasm() must be awaited first!");
1038 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1039 return nativeResponseValue;
1041 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1043 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
1044 if(!isWasmInitialized) {
1045 throw new Error("initializeWasm() must be awaited first!");
1047 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1048 return nativeResponseValue;
1050 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1052 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1053 if(!isWasmInitialized) {
1054 throw new Error("initializeWasm() must be awaited first!");
1056 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1057 return nativeResponseValue;
1059 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1061 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1062 if(!isWasmInitialized) {
1063 throw new Error("initializeWasm() must be awaited first!");
1065 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1066 return nativeResponseValue;
1068 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1070 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1071 if(!isWasmInitialized) {
1072 throw new Error("initializeWasm() must be awaited first!");
1074 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1075 return nativeResponseValue;
1077 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1079 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1080 if(!isWasmInitialized) {
1081 throw new Error("initializeWasm() must be awaited first!");
1083 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1084 return nativeResponseValue;
1086 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1088 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1089 if(!isWasmInitialized) {
1090 throw new Error("initializeWasm() must be awaited first!");
1092 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1093 return nativeResponseValue;
1096 export class LDKCOption_u64Z {
1097 protected constructor() {}
1100 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1101 if(!isWasmInitialized) {
1102 throw new Error("initializeWasm() must be awaited first!");
1104 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1105 return nativeResponseValue;
1108 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1109 if(!isWasmInitialized) {
1110 throw new Error("initializeWasm() must be awaited first!");
1112 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1113 return nativeResponseValue;
1115 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1117 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
1118 if(!isWasmInitialized) {
1119 throw new Error("initializeWasm() must be awaited first!");
1121 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1122 return nativeResponseValue;
1124 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1126 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1127 if(!isWasmInitialized) {
1128 throw new Error("initializeWasm() must be awaited first!");
1130 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1131 return nativeResponseValue;
1133 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1135 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1136 if(!isWasmInitialized) {
1137 throw new Error("initializeWasm() must be awaited first!");
1139 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1140 return nativeResponseValue;
1142 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1144 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1145 if(!isWasmInitialized) {
1146 throw new Error("initializeWasm() must be awaited first!");
1148 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1149 return nativeResponseValue;
1151 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1153 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1154 if(!isWasmInitialized) {
1155 throw new Error("initializeWasm() must be awaited first!");
1157 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1158 return nativeResponseValue;
1160 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1162 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1163 if(!isWasmInitialized) {
1164 throw new Error("initializeWasm() must be awaited first!");
1166 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1167 return nativeResponseValue;
1169 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1171 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1172 if(!isWasmInitialized) {
1173 throw new Error("initializeWasm() must be awaited first!");
1175 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1176 return nativeResponseValue;
1178 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1180 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1181 if(!isWasmInitialized) {
1182 throw new Error("initializeWasm() must be awaited first!");
1184 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1185 return nativeResponseValue;
1188 export class LDKPaymentPurpose {
1189 protected constructor() {}
1192 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1193 if(!isWasmInitialized) {
1194 throw new Error("initializeWasm() must be awaited first!");
1196 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1197 return nativeResponseValue;
1200 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1201 if(!isWasmInitialized) {
1202 throw new Error("initializeWasm() must be awaited first!");
1204 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1205 return nativeResponseValue;
1208 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1209 if(!isWasmInitialized) {
1210 throw new Error("initializeWasm() must be awaited first!");
1212 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1213 return nativeResponseValue;
1216 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1217 if(!isWasmInitialized) {
1218 throw new Error("initializeWasm() must be awaited first!");
1220 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1221 return nativeResponseValue;
1223 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1225 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: number): number {
1226 if(!isWasmInitialized) {
1227 throw new Error("initializeWasm() must be awaited first!");
1229 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1230 return nativeResponseValue;
1232 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1234 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: number): number {
1235 if(!isWasmInitialized) {
1236 throw new Error("initializeWasm() must be awaited first!");
1238 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1239 return nativeResponseValue;
1242 export class LDKClosureReason {
1243 protected constructor() {}
1246 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1247 if(!isWasmInitialized) {
1248 throw new Error("initializeWasm() must be awaited first!");
1250 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1251 return nativeResponseValue;
1254 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1255 if(!isWasmInitialized) {
1256 throw new Error("initializeWasm() must be awaited first!");
1258 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1259 return nativeResponseValue;
1262 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1263 if(!isWasmInitialized) {
1264 throw new Error("initializeWasm() must be awaited first!");
1266 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1267 return nativeResponseValue;
1270 export class LDKCOption_ClosureReasonZ {
1271 protected constructor() {}
1274 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1275 if(!isWasmInitialized) {
1276 throw new Error("initializeWasm() must be awaited first!");
1278 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1279 return nativeResponseValue;
1282 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1283 if(!isWasmInitialized) {
1284 throw new Error("initializeWasm() must be awaited first!");
1286 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1287 return nativeResponseValue;
1289 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1291 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1292 if(!isWasmInitialized) {
1293 throw new Error("initializeWasm() must be awaited first!");
1295 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1296 return nativeResponseValue;
1298 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1300 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1301 if(!isWasmInitialized) {
1302 throw new Error("initializeWasm() must be awaited first!");
1304 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1305 return nativeResponseValue;
1308 export class LDKHTLCDestination {
1309 protected constructor() {}
1312 export function LDKHTLCDestination_ty_from_ptr(ptr: number): number {
1313 if(!isWasmInitialized) {
1314 throw new Error("initializeWasm() must be awaited first!");
1316 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1317 return nativeResponseValue;
1320 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: number): number {
1321 if(!isWasmInitialized) {
1322 throw new Error("initializeWasm() must be awaited first!");
1324 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1325 return nativeResponseValue;
1328 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: number): number {
1329 if(!isWasmInitialized) {
1330 throw new Error("initializeWasm() must be awaited first!");
1332 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1333 return nativeResponseValue;
1336 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: number): bigint {
1337 if(!isWasmInitialized) {
1338 throw new Error("initializeWasm() must be awaited first!");
1340 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1341 return nativeResponseValue;
1344 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: number): number {
1345 if(!isWasmInitialized) {
1346 throw new Error("initializeWasm() must be awaited first!");
1348 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1349 return nativeResponseValue;
1352 export class LDKCOption_HTLCDestinationZ {
1353 protected constructor() {}
1356 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: number): number {
1357 if(!isWasmInitialized) {
1358 throw new Error("initializeWasm() must be awaited first!");
1360 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1361 return nativeResponseValue;
1364 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: number): number {
1365 if(!isWasmInitialized) {
1366 throw new Error("initializeWasm() must be awaited first!");
1368 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1369 return nativeResponseValue;
1371 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1373 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: number): number {
1374 if(!isWasmInitialized) {
1375 throw new Error("initializeWasm() must be awaited first!");
1377 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1378 return nativeResponseValue;
1380 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1382 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: number): number {
1383 if(!isWasmInitialized) {
1384 throw new Error("initializeWasm() must be awaited first!");
1386 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1387 return nativeResponseValue;
1390 export class LDKNetworkUpdate {
1391 protected constructor() {}
1394 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1395 if(!isWasmInitialized) {
1396 throw new Error("initializeWasm() must be awaited first!");
1398 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1399 return nativeResponseValue;
1402 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1403 if(!isWasmInitialized) {
1404 throw new Error("initializeWasm() must be awaited first!");
1406 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1407 return nativeResponseValue;
1410 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: number): bigint {
1411 if(!isWasmInitialized) {
1412 throw new Error("initializeWasm() must be awaited first!");
1414 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1415 return nativeResponseValue;
1418 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: number): boolean {
1419 if(!isWasmInitialized) {
1420 throw new Error("initializeWasm() must be awaited first!");
1422 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1423 return nativeResponseValue;
1426 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1427 if(!isWasmInitialized) {
1428 throw new Error("initializeWasm() must be awaited first!");
1430 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1431 return nativeResponseValue;
1434 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1435 if(!isWasmInitialized) {
1436 throw new Error("initializeWasm() must be awaited first!");
1438 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1439 return nativeResponseValue;
1442 export class LDKCOption_NetworkUpdateZ {
1443 protected constructor() {}
1446 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1447 if(!isWasmInitialized) {
1448 throw new Error("initializeWasm() must be awaited first!");
1450 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1451 return nativeResponseValue;
1454 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1455 if(!isWasmInitialized) {
1456 throw new Error("initializeWasm() must be awaited first!");
1458 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1459 return nativeResponseValue;
1462 export class LDKSpendableOutputDescriptor {
1463 protected constructor() {}
1466 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1467 if(!isWasmInitialized) {
1468 throw new Error("initializeWasm() must be awaited first!");
1470 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1471 return nativeResponseValue;
1474 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1475 if(!isWasmInitialized) {
1476 throw new Error("initializeWasm() must be awaited first!");
1478 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1479 return nativeResponseValue;
1482 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1483 if(!isWasmInitialized) {
1484 throw new Error("initializeWasm() must be awaited first!");
1486 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1487 return nativeResponseValue;
1490 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1495 return nativeResponseValue;
1498 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1499 if(!isWasmInitialized) {
1500 throw new Error("initializeWasm() must be awaited first!");
1502 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1503 return nativeResponseValue;
1506 export class LDKEvent {
1507 protected constructor() {}
1510 export function LDKEvent_ty_from_ptr(ptr: number): number {
1511 if(!isWasmInitialized) {
1512 throw new Error("initializeWasm() must be awaited first!");
1514 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1515 return nativeResponseValue;
1518 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1519 if(!isWasmInitialized) {
1520 throw new Error("initializeWasm() must be awaited first!");
1522 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1523 return nativeResponseValue;
1526 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: number): number {
1527 if(!isWasmInitialized) {
1528 throw new Error("initializeWasm() must be awaited first!");
1530 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1531 return nativeResponseValue;
1534 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1535 if(!isWasmInitialized) {
1536 throw new Error("initializeWasm() must be awaited first!");
1538 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1539 return nativeResponseValue;
1542 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1543 if(!isWasmInitialized) {
1544 throw new Error("initializeWasm() must be awaited first!");
1546 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1547 return nativeResponseValue;
1550 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1551 if(!isWasmInitialized) {
1552 throw new Error("initializeWasm() must be awaited first!");
1554 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1555 return nativeResponseValue;
1558 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1559 if(!isWasmInitialized) {
1560 throw new Error("initializeWasm() must be awaited first!");
1562 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1563 return nativeResponseValue;
1566 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: number): bigint {
1567 if(!isWasmInitialized) {
1568 throw new Error("initializeWasm() must be awaited first!");
1570 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1571 return nativeResponseValue;
1574 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1575 if(!isWasmInitialized) {
1576 throw new Error("initializeWasm() must be awaited first!");
1578 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1579 return nativeResponseValue;
1582 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: number): number {
1583 if(!isWasmInitialized) {
1584 throw new Error("initializeWasm() must be awaited first!");
1586 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1587 return nativeResponseValue;
1590 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: number): bigint {
1591 if(!isWasmInitialized) {
1592 throw new Error("initializeWasm() must be awaited first!");
1594 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1595 return nativeResponseValue;
1598 export function LDKEvent_PaymentClaimed_get_purpose(ptr: number): number {
1599 if(!isWasmInitialized) {
1600 throw new Error("initializeWasm() must be awaited first!");
1602 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1603 return nativeResponseValue;
1606 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1607 if(!isWasmInitialized) {
1608 throw new Error("initializeWasm() must be awaited first!");
1610 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1611 return nativeResponseValue;
1614 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1615 if(!isWasmInitialized) {
1616 throw new Error("initializeWasm() must be awaited first!");
1618 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1619 return nativeResponseValue;
1622 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1623 if(!isWasmInitialized) {
1624 throw new Error("initializeWasm() must be awaited first!");
1626 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1627 return nativeResponseValue;
1630 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1631 if(!isWasmInitialized) {
1632 throw new Error("initializeWasm() must be awaited first!");
1634 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1635 return nativeResponseValue;
1638 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1639 if(!isWasmInitialized) {
1640 throw new Error("initializeWasm() must be awaited first!");
1642 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1643 return nativeResponseValue;
1646 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1647 if(!isWasmInitialized) {
1648 throw new Error("initializeWasm() must be awaited first!");
1650 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1651 return nativeResponseValue;
1654 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1655 if(!isWasmInitialized) {
1656 throw new Error("initializeWasm() must be awaited first!");
1658 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1659 return nativeResponseValue;
1662 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1663 if(!isWasmInitialized) {
1664 throw new Error("initializeWasm() must be awaited first!");
1666 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1667 return nativeResponseValue;
1670 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1671 if(!isWasmInitialized) {
1672 throw new Error("initializeWasm() must be awaited first!");
1674 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1675 return nativeResponseValue;
1678 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1679 if(!isWasmInitialized) {
1680 throw new Error("initializeWasm() must be awaited first!");
1682 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1683 return nativeResponseValue;
1686 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1687 if(!isWasmInitialized) {
1688 throw new Error("initializeWasm() must be awaited first!");
1690 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1691 return nativeResponseValue;
1694 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1695 if(!isWasmInitialized) {
1696 throw new Error("initializeWasm() must be awaited first!");
1698 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1699 return nativeResponseValue;
1702 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1703 if(!isWasmInitialized) {
1704 throw new Error("initializeWasm() must be awaited first!");
1706 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1707 return nativeResponseValue;
1710 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1711 if(!isWasmInitialized) {
1712 throw new Error("initializeWasm() must be awaited first!");
1714 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1715 return nativeResponseValue;
1718 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1719 if(!isWasmInitialized) {
1720 throw new Error("initializeWasm() must be awaited first!");
1722 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1723 return nativeResponseValue;
1726 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1727 if(!isWasmInitialized) {
1728 throw new Error("initializeWasm() must be awaited first!");
1730 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1731 return nativeResponseValue;
1734 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1735 if(!isWasmInitialized) {
1736 throw new Error("initializeWasm() must be awaited first!");
1738 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1739 return nativeResponseValue;
1742 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: number): number {
1743 if(!isWasmInitialized) {
1744 throw new Error("initializeWasm() must be awaited first!");
1746 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
1747 return nativeResponseValue;
1750 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: number): number {
1751 if(!isWasmInitialized) {
1752 throw new Error("initializeWasm() must be awaited first!");
1754 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
1755 return nativeResponseValue;
1758 export function LDKEvent_ProbeSuccessful_get_path(ptr: number): number {
1759 if(!isWasmInitialized) {
1760 throw new Error("initializeWasm() must be awaited first!");
1762 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
1763 return nativeResponseValue;
1766 export function LDKEvent_ProbeFailed_get_payment_id(ptr: number): number {
1767 if(!isWasmInitialized) {
1768 throw new Error("initializeWasm() must be awaited first!");
1770 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
1771 return nativeResponseValue;
1774 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: number): number {
1775 if(!isWasmInitialized) {
1776 throw new Error("initializeWasm() must be awaited first!");
1778 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
1779 return nativeResponseValue;
1782 export function LDKEvent_ProbeFailed_get_path(ptr: number): number {
1783 if(!isWasmInitialized) {
1784 throw new Error("initializeWasm() must be awaited first!");
1786 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
1787 return nativeResponseValue;
1790 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: number): number {
1791 if(!isWasmInitialized) {
1792 throw new Error("initializeWasm() must be awaited first!");
1794 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
1795 return nativeResponseValue;
1798 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1799 if(!isWasmInitialized) {
1800 throw new Error("initializeWasm() must be awaited first!");
1802 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1803 return nativeResponseValue;
1806 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1807 if(!isWasmInitialized) {
1808 throw new Error("initializeWasm() must be awaited first!");
1810 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1811 return nativeResponseValue;
1814 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: number): number {
1815 if(!isWasmInitialized) {
1816 throw new Error("initializeWasm() must be awaited first!");
1818 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1819 return nativeResponseValue;
1822 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: number): number {
1823 if(!isWasmInitialized) {
1824 throw new Error("initializeWasm() must be awaited first!");
1826 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1827 return nativeResponseValue;
1830 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1831 if(!isWasmInitialized) {
1832 throw new Error("initializeWasm() must be awaited first!");
1834 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1835 return nativeResponseValue;
1838 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1839 if(!isWasmInitialized) {
1840 throw new Error("initializeWasm() must be awaited first!");
1842 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1843 return nativeResponseValue;
1846 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1847 if(!isWasmInitialized) {
1848 throw new Error("initializeWasm() must be awaited first!");
1850 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1851 return nativeResponseValue;
1854 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1855 if(!isWasmInitialized) {
1856 throw new Error("initializeWasm() must be awaited first!");
1858 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1859 return nativeResponseValue;
1862 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1863 if(!isWasmInitialized) {
1864 throw new Error("initializeWasm() must be awaited first!");
1866 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1867 return nativeResponseValue;
1870 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1871 if(!isWasmInitialized) {
1872 throw new Error("initializeWasm() must be awaited first!");
1874 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1875 return nativeResponseValue;
1878 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1879 if(!isWasmInitialized) {
1880 throw new Error("initializeWasm() must be awaited first!");
1882 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1883 return nativeResponseValue;
1886 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1887 if(!isWasmInitialized) {
1888 throw new Error("initializeWasm() must be awaited first!");
1890 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1891 return nativeResponseValue;
1894 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1895 if(!isWasmInitialized) {
1896 throw new Error("initializeWasm() must be awaited first!");
1898 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1899 return nativeResponseValue;
1902 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1903 if(!isWasmInitialized) {
1904 throw new Error("initializeWasm() must be awaited first!");
1906 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1907 return nativeResponseValue;
1910 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1911 if(!isWasmInitialized) {
1912 throw new Error("initializeWasm() must be awaited first!");
1914 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1915 return nativeResponseValue;
1918 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1919 if(!isWasmInitialized) {
1920 throw new Error("initializeWasm() must be awaited first!");
1922 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1923 return nativeResponseValue;
1926 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: number): number {
1927 if(!isWasmInitialized) {
1928 throw new Error("initializeWasm() must be awaited first!");
1930 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
1931 return nativeResponseValue;
1934 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: number): number {
1935 if(!isWasmInitialized) {
1936 throw new Error("initializeWasm() must be awaited first!");
1938 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
1939 return nativeResponseValue;
1942 export class LDKCOption_EventZ {
1943 protected constructor() {}
1946 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1947 if(!isWasmInitialized) {
1948 throw new Error("initializeWasm() must be awaited first!");
1950 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1951 return nativeResponseValue;
1954 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1955 if(!isWasmInitialized) {
1956 throw new Error("initializeWasm() must be awaited first!");
1958 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1959 return nativeResponseValue;
1961 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1963 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1964 if(!isWasmInitialized) {
1965 throw new Error("initializeWasm() must be awaited first!");
1967 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1968 return nativeResponseValue;
1970 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1972 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1973 if(!isWasmInitialized) {
1974 throw new Error("initializeWasm() must be awaited first!");
1976 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1977 return nativeResponseValue;
1980 export class LDKErrorAction {
1981 protected constructor() {}
1984 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1985 if(!isWasmInitialized) {
1986 throw new Error("initializeWasm() must be awaited first!");
1988 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1989 return nativeResponseValue;
1992 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1993 if(!isWasmInitialized) {
1994 throw new Error("initializeWasm() must be awaited first!");
1996 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1997 return nativeResponseValue;
2000 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
2001 if(!isWasmInitialized) {
2002 throw new Error("initializeWasm() must be awaited first!");
2004 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2005 return nativeResponseValue;
2008 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
2009 if(!isWasmInitialized) {
2010 throw new Error("initializeWasm() must be awaited first!");
2012 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2013 return nativeResponseValue;
2016 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
2017 if(!isWasmInitialized) {
2018 throw new Error("initializeWasm() must be awaited first!");
2020 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2021 return nativeResponseValue;
2024 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
2025 if(!isWasmInitialized) {
2026 throw new Error("initializeWasm() must be awaited first!");
2028 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2029 return nativeResponseValue;
2032 export class LDKMessageSendEvent {
2033 protected constructor() {}
2036 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
2037 if(!isWasmInitialized) {
2038 throw new Error("initializeWasm() must be awaited first!");
2040 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2041 return nativeResponseValue;
2044 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
2045 if(!isWasmInitialized) {
2046 throw new Error("initializeWasm() must be awaited first!");
2048 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2049 return nativeResponseValue;
2052 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
2053 if(!isWasmInitialized) {
2054 throw new Error("initializeWasm() must be awaited first!");
2056 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2057 return nativeResponseValue;
2060 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
2061 if(!isWasmInitialized) {
2062 throw new Error("initializeWasm() must be awaited first!");
2064 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2065 return nativeResponseValue;
2068 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
2069 if(!isWasmInitialized) {
2070 throw new Error("initializeWasm() must be awaited first!");
2072 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2073 return nativeResponseValue;
2076 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
2077 if(!isWasmInitialized) {
2078 throw new Error("initializeWasm() must be awaited first!");
2080 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2081 return nativeResponseValue;
2084 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
2085 if(!isWasmInitialized) {
2086 throw new Error("initializeWasm() must be awaited first!");
2088 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2089 return nativeResponseValue;
2092 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
2093 if(!isWasmInitialized) {
2094 throw new Error("initializeWasm() must be awaited first!");
2096 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2097 return nativeResponseValue;
2100 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
2101 if(!isWasmInitialized) {
2102 throw new Error("initializeWasm() must be awaited first!");
2104 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2105 return nativeResponseValue;
2108 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: number): number {
2109 if(!isWasmInitialized) {
2110 throw new Error("initializeWasm() must be awaited first!");
2112 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2113 return nativeResponseValue;
2116 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: number): number {
2117 if(!isWasmInitialized) {
2118 throw new Error("initializeWasm() must be awaited first!");
2120 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2121 return nativeResponseValue;
2124 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
2125 if(!isWasmInitialized) {
2126 throw new Error("initializeWasm() must be awaited first!");
2128 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2129 return nativeResponseValue;
2132 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
2133 if(!isWasmInitialized) {
2134 throw new Error("initializeWasm() must be awaited first!");
2136 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2137 return nativeResponseValue;
2140 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
2141 if(!isWasmInitialized) {
2142 throw new Error("initializeWasm() must be awaited first!");
2144 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2145 return nativeResponseValue;
2148 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
2149 if(!isWasmInitialized) {
2150 throw new Error("initializeWasm() must be awaited first!");
2152 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2153 return nativeResponseValue;
2156 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
2157 if(!isWasmInitialized) {
2158 throw new Error("initializeWasm() must be awaited first!");
2160 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2161 return nativeResponseValue;
2164 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
2165 if(!isWasmInitialized) {
2166 throw new Error("initializeWasm() must be awaited first!");
2168 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2169 return nativeResponseValue;
2172 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
2173 if(!isWasmInitialized) {
2174 throw new Error("initializeWasm() must be awaited first!");
2176 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2177 return nativeResponseValue;
2180 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
2181 if(!isWasmInitialized) {
2182 throw new Error("initializeWasm() must be awaited first!");
2184 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2185 return nativeResponseValue;
2188 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
2189 if(!isWasmInitialized) {
2190 throw new Error("initializeWasm() must be awaited first!");
2192 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2193 return nativeResponseValue;
2196 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
2197 if(!isWasmInitialized) {
2198 throw new Error("initializeWasm() must be awaited first!");
2200 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2201 return nativeResponseValue;
2204 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2205 if(!isWasmInitialized) {
2206 throw new Error("initializeWasm() must be awaited first!");
2208 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2209 return nativeResponseValue;
2212 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2213 if(!isWasmInitialized) {
2214 throw new Error("initializeWasm() must be awaited first!");
2216 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2217 return nativeResponseValue;
2220 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2221 if(!isWasmInitialized) {
2222 throw new Error("initializeWasm() must be awaited first!");
2224 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2225 return nativeResponseValue;
2228 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2229 if(!isWasmInitialized) {
2230 throw new Error("initializeWasm() must be awaited first!");
2232 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2233 return nativeResponseValue;
2236 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2237 if(!isWasmInitialized) {
2238 throw new Error("initializeWasm() must be awaited first!");
2240 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2241 return nativeResponseValue;
2244 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2245 if(!isWasmInitialized) {
2246 throw new Error("initializeWasm() must be awaited first!");
2248 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2249 return nativeResponseValue;
2252 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2253 if(!isWasmInitialized) {
2254 throw new Error("initializeWasm() must be awaited first!");
2256 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2257 return nativeResponseValue;
2260 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2261 if(!isWasmInitialized) {
2262 throw new Error("initializeWasm() must be awaited first!");
2264 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2265 return nativeResponseValue;
2268 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2269 if(!isWasmInitialized) {
2270 throw new Error("initializeWasm() must be awaited first!");
2272 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2273 return nativeResponseValue;
2276 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2277 if(!isWasmInitialized) {
2278 throw new Error("initializeWasm() must be awaited first!");
2280 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2281 return nativeResponseValue;
2284 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2285 if(!isWasmInitialized) {
2286 throw new Error("initializeWasm() must be awaited first!");
2288 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2289 return nativeResponseValue;
2292 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2293 if(!isWasmInitialized) {
2294 throw new Error("initializeWasm() must be awaited first!");
2296 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2297 return nativeResponseValue;
2300 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2301 if(!isWasmInitialized) {
2302 throw new Error("initializeWasm() must be awaited first!");
2304 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2305 return nativeResponseValue;
2308 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2309 if(!isWasmInitialized) {
2310 throw new Error("initializeWasm() must be awaited first!");
2312 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2313 return nativeResponseValue;
2316 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2321 return nativeResponseValue;
2324 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2325 if(!isWasmInitialized) {
2326 throw new Error("initializeWasm() must be awaited first!");
2328 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2329 return nativeResponseValue;
2332 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2333 if(!isWasmInitialized) {
2334 throw new Error("initializeWasm() must be awaited first!");
2336 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2337 return nativeResponseValue;
2340 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2341 if(!isWasmInitialized) {
2342 throw new Error("initializeWasm() must be awaited first!");
2344 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2345 return nativeResponseValue;
2347 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2349 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2350 if(!isWasmInitialized) {
2351 throw new Error("initializeWasm() must be awaited first!");
2353 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2354 return nativeResponseValue;
2356 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2358 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2359 if(!isWasmInitialized) {
2360 throw new Error("initializeWasm() must be awaited first!");
2362 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2363 return nativeResponseValue;
2365 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2367 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
2368 if(!isWasmInitialized) {
2369 throw new Error("initializeWasm() must be awaited first!");
2371 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2372 return nativeResponseValue;
2374 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2376 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
2377 if(!isWasmInitialized) {
2378 throw new Error("initializeWasm() must be awaited first!");
2380 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2381 return nativeResponseValue;
2383 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2385 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2386 if(!isWasmInitialized) {
2387 throw new Error("initializeWasm() must be awaited first!");
2389 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2390 // debug statements here
2392 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2394 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2395 if(!isWasmInitialized) {
2396 throw new Error("initializeWasm() must be awaited first!");
2398 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2399 return nativeResponseValue;
2402 export class LDKMonitorEvent {
2403 protected constructor() {}
2406 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
2407 if(!isWasmInitialized) {
2408 throw new Error("initializeWasm() must be awaited first!");
2410 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2411 return nativeResponseValue;
2414 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
2415 if(!isWasmInitialized) {
2416 throw new Error("initializeWasm() must be awaited first!");
2418 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2419 return nativeResponseValue;
2422 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
2423 if(!isWasmInitialized) {
2424 throw new Error("initializeWasm() must be awaited first!");
2426 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2427 return nativeResponseValue;
2430 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
2431 if(!isWasmInitialized) {
2432 throw new Error("initializeWasm() must be awaited first!");
2434 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2435 return nativeResponseValue;
2438 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
2439 if(!isWasmInitialized) {
2440 throw new Error("initializeWasm() must be awaited first!");
2442 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2443 return nativeResponseValue;
2446 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
2447 if(!isWasmInitialized) {
2448 throw new Error("initializeWasm() must be awaited first!");
2450 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2451 return nativeResponseValue;
2453 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2455 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: number): number {
2456 if(!isWasmInitialized) {
2457 throw new Error("initializeWasm() must be awaited first!");
2459 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2460 return nativeResponseValue;
2462 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2464 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: number): number {
2465 if(!isWasmInitialized) {
2466 throw new Error("initializeWasm() must be awaited first!");
2468 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2469 return nativeResponseValue;
2471 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2473 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: number): number {
2474 if(!isWasmInitialized) {
2475 throw new Error("initializeWasm() must be awaited first!");
2477 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2478 return nativeResponseValue;
2481 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2482 protected constructor() {}
2485 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2486 if(!isWasmInitialized) {
2487 throw new Error("initializeWasm() must be awaited first!");
2489 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2490 return nativeResponseValue;
2493 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2494 if(!isWasmInitialized) {
2495 throw new Error("initializeWasm() must be awaited first!");
2497 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2498 return nativeResponseValue;
2500 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2502 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2503 if(!isWasmInitialized) {
2504 throw new Error("initializeWasm() must be awaited first!");
2506 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2507 return nativeResponseValue;
2509 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2511 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2512 if(!isWasmInitialized) {
2513 throw new Error("initializeWasm() must be awaited first!");
2515 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2516 return nativeResponseValue;
2518 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2520 export function C2Tuple_u64u64Z_get_a(owner: number): bigint {
2521 if(!isWasmInitialized) {
2522 throw new Error("initializeWasm() must be awaited first!");
2524 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2525 return nativeResponseValue;
2527 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2529 export function C2Tuple_u64u64Z_get_b(owner: number): bigint {
2530 if(!isWasmInitialized) {
2531 throw new Error("initializeWasm() must be awaited first!");
2533 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2534 return nativeResponseValue;
2537 export class LDKCOption_C2Tuple_u64u64ZZ {
2538 protected constructor() {}
2541 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: number): number {
2542 if(!isWasmInitialized) {
2543 throw new Error("initializeWasm() must be awaited first!");
2545 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2546 return nativeResponseValue;
2549 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: number): number {
2550 if(!isWasmInitialized) {
2551 throw new Error("initializeWasm() must be awaited first!");
2553 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2554 return nativeResponseValue;
2557 export interface LDKLogger {
2558 log (record: number): void;
2562 export function LDKLogger_new(impl: LDKLogger): number {
2563 if(!isWasmInitialized) {
2564 throw new Error("initializeWasm() must be awaited first!");
2566 var new_obj_idx = js_objs.length;
2567 for (var i = 0; i < js_objs.length; i++) {
2568 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2570 js_objs[i] = new WeakRef(impl);
2571 return wasm.TS_LDKLogger_new(i);
2573 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2575 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2576 if(!isWasmInitialized) {
2577 throw new Error("initializeWasm() must be awaited first!");
2579 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2580 return nativeResponseValue;
2582 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2584 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2585 if(!isWasmInitialized) {
2586 throw new Error("initializeWasm() must be awaited first!");
2588 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2589 return nativeResponseValue;
2591 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2593 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2594 if(!isWasmInitialized) {
2595 throw new Error("initializeWasm() must be awaited first!");
2597 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2598 return nativeResponseValue;
2600 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2602 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2603 if(!isWasmInitialized) {
2604 throw new Error("initializeWasm() must be awaited first!");
2606 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2607 return nativeResponseValue;
2609 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2611 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2612 if(!isWasmInitialized) {
2613 throw new Error("initializeWasm() must be awaited first!");
2615 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2616 return nativeResponseValue;
2618 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2620 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2621 if(!isWasmInitialized) {
2622 throw new Error("initializeWasm() must be awaited first!");
2624 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2625 return nativeResponseValue;
2627 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2629 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2630 if(!isWasmInitialized) {
2631 throw new Error("initializeWasm() must be awaited first!");
2633 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2634 return nativeResponseValue;
2636 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2638 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2639 if(!isWasmInitialized) {
2640 throw new Error("initializeWasm() must be awaited first!");
2642 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2643 return nativeResponseValue;
2645 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2647 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2648 if(!isWasmInitialized) {
2649 throw new Error("initializeWasm() must be awaited first!");
2651 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2652 return nativeResponseValue;
2654 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2656 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2657 if(!isWasmInitialized) {
2658 throw new Error("initializeWasm() must be awaited first!");
2660 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2661 return nativeResponseValue;
2663 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2665 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2666 if(!isWasmInitialized) {
2667 throw new Error("initializeWasm() must be awaited first!");
2669 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2670 return nativeResponseValue;
2672 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2674 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2675 if(!isWasmInitialized) {
2676 throw new Error("initializeWasm() must be awaited first!");
2678 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2679 return nativeResponseValue;
2681 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2683 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2684 if(!isWasmInitialized) {
2685 throw new Error("initializeWasm() must be awaited first!");
2687 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2688 return nativeResponseValue;
2690 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2692 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2693 if(!isWasmInitialized) {
2694 throw new Error("initializeWasm() must be awaited first!");
2696 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2697 return nativeResponseValue;
2699 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2701 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2702 if(!isWasmInitialized) {
2703 throw new Error("initializeWasm() must be awaited first!");
2705 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2706 return nativeResponseValue;
2708 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2710 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2711 if(!isWasmInitialized) {
2712 throw new Error("initializeWasm() must be awaited first!");
2714 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2715 return nativeResponseValue;
2718 export interface LDKAccess {
2719 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2723 export function LDKAccess_new(impl: LDKAccess): number {
2724 if(!isWasmInitialized) {
2725 throw new Error("initializeWasm() must be awaited first!");
2727 var new_obj_idx = js_objs.length;
2728 for (var i = 0; i < js_objs.length; i++) {
2729 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2731 js_objs[i] = new WeakRef(impl);
2732 return wasm.TS_LDKAccess_new(i);
2734 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2736 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2737 if(!isWasmInitialized) {
2738 throw new Error("initializeWasm() must be awaited first!");
2740 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2741 return nativeResponseValue;
2744 export class LDKCOption_AccessZ {
2745 protected constructor() {}
2748 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2749 if(!isWasmInitialized) {
2750 throw new Error("initializeWasm() must be awaited first!");
2752 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2753 return nativeResponseValue;
2756 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2757 if(!isWasmInitialized) {
2758 throw new Error("initializeWasm() must be awaited first!");
2760 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2761 return nativeResponseValue;
2763 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2765 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2766 if(!isWasmInitialized) {
2767 throw new Error("initializeWasm() must be awaited first!");
2769 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2770 return nativeResponseValue;
2772 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2774 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2775 if(!isWasmInitialized) {
2776 throw new Error("initializeWasm() must be awaited first!");
2778 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2779 return nativeResponseValue;
2781 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2783 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2784 if(!isWasmInitialized) {
2785 throw new Error("initializeWasm() must be awaited first!");
2787 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2788 return nativeResponseValue;
2790 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2792 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2793 if(!isWasmInitialized) {
2794 throw new Error("initializeWasm() must be awaited first!");
2796 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2797 return nativeResponseValue;
2799 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2801 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2802 if(!isWasmInitialized) {
2803 throw new Error("initializeWasm() must be awaited first!");
2805 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2806 return nativeResponseValue;
2808 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2810 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2811 if(!isWasmInitialized) {
2812 throw new Error("initializeWasm() must be awaited first!");
2814 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2815 // debug statements here
2817 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2819 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2820 if(!isWasmInitialized) {
2821 throw new Error("initializeWasm() must be awaited first!");
2823 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2824 return nativeResponseValue;
2826 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2828 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
2829 if(!isWasmInitialized) {
2830 throw new Error("initializeWasm() must be awaited first!");
2832 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2833 return nativeResponseValue;
2835 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2837 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
2838 if(!isWasmInitialized) {
2839 throw new Error("initializeWasm() must be awaited first!");
2841 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2842 return nativeResponseValue;
2844 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2846 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2847 if(!isWasmInitialized) {
2848 throw new Error("initializeWasm() must be awaited first!");
2850 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2851 return nativeResponseValue;
2853 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2855 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2856 if(!isWasmInitialized) {
2857 throw new Error("initializeWasm() must be awaited first!");
2859 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2860 return nativeResponseValue;
2862 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2864 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2865 if(!isWasmInitialized) {
2866 throw new Error("initializeWasm() must be awaited first!");
2868 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2869 return nativeResponseValue;
2871 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2873 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2874 if(!isWasmInitialized) {
2875 throw new Error("initializeWasm() must be awaited first!");
2877 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2878 return nativeResponseValue;
2881 export class LDKNetAddress {
2882 protected constructor() {}
2885 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2886 if(!isWasmInitialized) {
2887 throw new Error("initializeWasm() must be awaited first!");
2889 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2890 return nativeResponseValue;
2893 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2894 if(!isWasmInitialized) {
2895 throw new Error("initializeWasm() must be awaited first!");
2897 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2898 return nativeResponseValue;
2901 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2902 if(!isWasmInitialized) {
2903 throw new Error("initializeWasm() must be awaited first!");
2905 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2906 return nativeResponseValue;
2909 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2910 if(!isWasmInitialized) {
2911 throw new Error("initializeWasm() must be awaited first!");
2913 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2914 return nativeResponseValue;
2917 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2918 if(!isWasmInitialized) {
2919 throw new Error("initializeWasm() must be awaited first!");
2921 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2922 return nativeResponseValue;
2925 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2926 if(!isWasmInitialized) {
2927 throw new Error("initializeWasm() must be awaited first!");
2929 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2930 return nativeResponseValue;
2933 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2934 if(!isWasmInitialized) {
2935 throw new Error("initializeWasm() must be awaited first!");
2937 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2938 return nativeResponseValue;
2941 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2942 if(!isWasmInitialized) {
2943 throw new Error("initializeWasm() must be awaited first!");
2945 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2946 return nativeResponseValue;
2949 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2950 if(!isWasmInitialized) {
2951 throw new Error("initializeWasm() must be awaited first!");
2953 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2954 return nativeResponseValue;
2957 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2958 if(!isWasmInitialized) {
2959 throw new Error("initializeWasm() must be awaited first!");
2961 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2962 return nativeResponseValue;
2965 export function LDKNetAddress_Hostname_get_hostname(ptr: number): number {
2966 if(!isWasmInitialized) {
2967 throw new Error("initializeWasm() must be awaited first!");
2969 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
2970 return nativeResponseValue;
2973 export function LDKNetAddress_Hostname_get_port(ptr: number): number {
2974 if(!isWasmInitialized) {
2975 throw new Error("initializeWasm() must be awaited first!");
2977 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
2978 return nativeResponseValue;
2980 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2982 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2983 if(!isWasmInitialized) {
2984 throw new Error("initializeWasm() must be awaited first!");
2986 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2987 return nativeResponseValue;
2989 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2991 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2992 if(!isWasmInitialized) {
2993 throw new Error("initializeWasm() must be awaited first!");
2995 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2996 return nativeResponseValue;
2998 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3000 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: number): number {
3001 if(!isWasmInitialized) {
3002 throw new Error("initializeWasm() must be awaited first!");
3004 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3005 return nativeResponseValue;
3007 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3009 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: number): number {
3010 if(!isWasmInitialized) {
3011 throw new Error("initializeWasm() must be awaited first!");
3013 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3014 return nativeResponseValue;
3016 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3018 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
3019 if(!isWasmInitialized) {
3020 throw new Error("initializeWasm() must be awaited first!");
3022 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3023 return nativeResponseValue;
3025 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3027 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
3028 if(!isWasmInitialized) {
3029 throw new Error("initializeWasm() must be awaited first!");
3031 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3032 return nativeResponseValue;
3034 // struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3036 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3041 return nativeResponseValue;
3043 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3045 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3050 return nativeResponseValue;
3053 export class LDKCOption_CVec_NetAddressZZ {
3054 protected constructor() {}
3057 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
3058 if(!isWasmInitialized) {
3059 throw new Error("initializeWasm() must be awaited first!");
3061 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3062 return nativeResponseValue;
3065 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
3066 if(!isWasmInitialized) {
3067 throw new Error("initializeWasm() must be awaited first!");
3069 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3070 return nativeResponseValue;
3072 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3074 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3075 if(!isWasmInitialized) {
3076 throw new Error("initializeWasm() must be awaited first!");
3078 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3079 return nativeResponseValue;
3081 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3083 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3084 if(!isWasmInitialized) {
3085 throw new Error("initializeWasm() must be awaited first!");
3087 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3088 return nativeResponseValue;
3090 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3092 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3093 if(!isWasmInitialized) {
3094 throw new Error("initializeWasm() must be awaited first!");
3096 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3097 return nativeResponseValue;
3099 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3101 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3102 if(!isWasmInitialized) {
3103 throw new Error("initializeWasm() must be awaited first!");
3105 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3106 return nativeResponseValue;
3108 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3110 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3111 if(!isWasmInitialized) {
3112 throw new Error("initializeWasm() must be awaited first!");
3114 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3115 return nativeResponseValue;
3117 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3119 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3120 if(!isWasmInitialized) {
3121 throw new Error("initializeWasm() must be awaited first!");
3123 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3124 return nativeResponseValue;
3126 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3128 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
3129 if(!isWasmInitialized) {
3130 throw new Error("initializeWasm() must be awaited first!");
3132 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3133 return nativeResponseValue;
3135 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3137 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
3138 if(!isWasmInitialized) {
3139 throw new Error("initializeWasm() must be awaited first!");
3141 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3142 return nativeResponseValue;
3144 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3146 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
3147 if(!isWasmInitialized) {
3148 throw new Error("initializeWasm() must be awaited first!");
3150 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3151 return nativeResponseValue;
3153 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3155 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
3156 if(!isWasmInitialized) {
3157 throw new Error("initializeWasm() must be awaited first!");
3159 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3160 // debug statements here
3162 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3164 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
3165 if(!isWasmInitialized) {
3166 throw new Error("initializeWasm() must be awaited first!");
3168 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3169 return nativeResponseValue;
3171 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3173 export function CResult_SignatureNoneZ_get_err(owner: number): void {
3174 if(!isWasmInitialized) {
3175 throw new Error("initializeWasm() must be awaited first!");
3177 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3178 // debug statements here
3180 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3182 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
3183 if(!isWasmInitialized) {
3184 throw new Error("initializeWasm() must be awaited first!");
3186 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
3187 return nativeResponseValue;
3189 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3191 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
3192 if(!isWasmInitialized) {
3193 throw new Error("initializeWasm() must be awaited first!");
3195 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
3196 return nativeResponseValue;
3198 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3200 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
3201 if(!isWasmInitialized) {
3202 throw new Error("initializeWasm() must be awaited first!");
3204 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3205 return nativeResponseValue;
3207 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3209 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
3210 if(!isWasmInitialized) {
3211 throw new Error("initializeWasm() must be awaited first!");
3213 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3214 // debug statements here
3216 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3218 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
3219 if(!isWasmInitialized) {
3220 throw new Error("initializeWasm() must be awaited first!");
3222 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3223 return nativeResponseValue;
3225 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3227 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
3228 if(!isWasmInitialized) {
3229 throw new Error("initializeWasm() must be awaited first!");
3231 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3232 // debug statements here
3235 export interface LDKBaseSign {
3236 get_per_commitment_point (idx: bigint): number;
3237 release_commitment_secret (idx: bigint): number;
3238 validate_holder_commitment (holder_tx: number, preimages: number): number;
3239 channel_keys_id (): number;
3240 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
3241 validate_counterparty_revocation (idx: bigint, secret: number): number;
3242 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
3243 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
3244 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
3245 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
3246 sign_closing_transaction (closing_tx: number): number;
3247 sign_channel_announcement (msg: number): number;
3248 ready_channel (channel_parameters: number): void;
3252 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 var new_obj_idx = js_objs.length;
3257 for (var i = 0; i < js_objs.length; i++) {
3258 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3260 js_objs[i] = new WeakRef(impl);
3261 return wasm.TS_LDKBaseSign_new(i);
3263 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3265 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
3266 if(!isWasmInitialized) {
3267 throw new Error("initializeWasm() must be awaited first!");
3269 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3270 return nativeResponseValue;
3272 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3274 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
3275 if(!isWasmInitialized) {
3276 throw new Error("initializeWasm() must be awaited first!");
3278 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3279 return nativeResponseValue;
3281 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3283 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
3284 if(!isWasmInitialized) {
3285 throw new Error("initializeWasm() must be awaited first!");
3287 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3288 return nativeResponseValue;
3290 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3292 export function BaseSign_channel_keys_id(this_arg: number): number {
3293 if(!isWasmInitialized) {
3294 throw new Error("initializeWasm() must be awaited first!");
3296 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3297 return nativeResponseValue;
3299 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3301 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
3302 if(!isWasmInitialized) {
3303 throw new Error("initializeWasm() must be awaited first!");
3305 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3306 return nativeResponseValue;
3308 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3310 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
3311 if(!isWasmInitialized) {
3312 throw new Error("initializeWasm() must be awaited first!");
3314 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3315 return nativeResponseValue;
3317 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3319 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
3320 if(!isWasmInitialized) {
3321 throw new Error("initializeWasm() must be awaited first!");
3323 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3324 return nativeResponseValue;
3326 // 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]
3328 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
3329 if(!isWasmInitialized) {
3330 throw new Error("initializeWasm() must be awaited first!");
3332 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3333 return nativeResponseValue;
3335 // 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
3337 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
3338 if(!isWasmInitialized) {
3339 throw new Error("initializeWasm() must be awaited first!");
3341 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3342 return nativeResponseValue;
3344 // 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
3346 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
3347 if(!isWasmInitialized) {
3348 throw new Error("initializeWasm() must be awaited first!");
3350 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3351 return nativeResponseValue;
3353 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3355 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
3356 if(!isWasmInitialized) {
3357 throw new Error("initializeWasm() must be awaited first!");
3359 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3360 return nativeResponseValue;
3362 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3364 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
3365 if(!isWasmInitialized) {
3366 throw new Error("initializeWasm() must be awaited first!");
3368 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3369 return nativeResponseValue;
3371 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3373 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
3374 if(!isWasmInitialized) {
3375 throw new Error("initializeWasm() must be awaited first!");
3377 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3378 // debug statements here
3380 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3382 export function BaseSign_get_pubkeys(this_arg: number): number {
3383 if(!isWasmInitialized) {
3384 throw new Error("initializeWasm() must be awaited first!");
3386 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3387 return nativeResponseValue;
3390 export interface LDKSign {
3395 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
3396 if(!isWasmInitialized) {
3397 throw new Error("initializeWasm() must be awaited first!");
3399 var new_obj_idx = js_objs.length;
3400 for (var i = 0; i < js_objs.length; i++) {
3401 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3403 js_objs[i] = new WeakRef(impl);
3404 return wasm.TS_LDKSign_new(i);
3406 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3408 export function Sign_write(this_arg: number): number {
3409 if(!isWasmInitialized) {
3410 throw new Error("initializeWasm() must be awaited first!");
3412 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3413 return nativeResponseValue;
3415 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3417 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3418 if(!isWasmInitialized) {
3419 throw new Error("initializeWasm() must be awaited first!");
3421 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3422 return nativeResponseValue;
3424 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3426 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3427 if(!isWasmInitialized) {
3428 throw new Error("initializeWasm() must be awaited first!");
3430 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3431 return nativeResponseValue;
3433 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3435 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3436 if(!isWasmInitialized) {
3437 throw new Error("initializeWasm() must be awaited first!");
3439 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3440 return nativeResponseValue;
3442 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3444 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3445 if(!isWasmInitialized) {
3446 throw new Error("initializeWasm() must be awaited first!");
3448 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3449 // debug statements here
3451 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3453 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3454 if(!isWasmInitialized) {
3455 throw new Error("initializeWasm() must be awaited first!");
3457 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3458 return nativeResponseValue;
3460 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3462 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3463 if(!isWasmInitialized) {
3464 throw new Error("initializeWasm() must be awaited first!");
3466 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3467 // debug statements here
3469 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3471 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3472 if(!isWasmInitialized) {
3473 throw new Error("initializeWasm() must be awaited first!");
3475 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3476 return nativeResponseValue;
3478 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3480 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3481 if(!isWasmInitialized) {
3482 throw new Error("initializeWasm() must be awaited first!");
3484 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3485 return nativeResponseValue;
3487 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3489 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3490 if(!isWasmInitialized) {
3491 throw new Error("initializeWasm() must be awaited first!");
3493 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3494 return nativeResponseValue;
3496 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3498 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3499 if(!isWasmInitialized) {
3500 throw new Error("initializeWasm() must be awaited first!");
3502 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3503 // debug statements here
3506 export class LDKCOption_u16Z {
3507 protected constructor() {}
3510 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3511 if(!isWasmInitialized) {
3512 throw new Error("initializeWasm() must be awaited first!");
3514 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3515 return nativeResponseValue;
3518 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3519 if(!isWasmInitialized) {
3520 throw new Error("initializeWasm() must be awaited first!");
3522 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3523 return nativeResponseValue;
3526 export class LDKAPIError {
3527 protected constructor() {}
3530 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3531 if(!isWasmInitialized) {
3532 throw new Error("initializeWasm() must be awaited first!");
3534 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3535 return nativeResponseValue;
3538 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3539 if(!isWasmInitialized) {
3540 throw new Error("initializeWasm() must be awaited first!");
3542 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3543 return nativeResponseValue;
3546 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3547 if(!isWasmInitialized) {
3548 throw new Error("initializeWasm() must be awaited first!");
3550 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3551 return nativeResponseValue;
3554 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3555 if(!isWasmInitialized) {
3556 throw new Error("initializeWasm() must be awaited first!");
3558 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3559 return nativeResponseValue;
3562 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3563 if(!isWasmInitialized) {
3564 throw new Error("initializeWasm() must be awaited first!");
3566 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3567 return nativeResponseValue;
3570 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3571 if(!isWasmInitialized) {
3572 throw new Error("initializeWasm() must be awaited first!");
3574 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3575 return nativeResponseValue;
3578 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3579 if(!isWasmInitialized) {
3580 throw new Error("initializeWasm() must be awaited first!");
3582 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3583 return nativeResponseValue;
3585 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3587 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3588 if(!isWasmInitialized) {
3589 throw new Error("initializeWasm() must be awaited first!");
3591 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3592 // debug statements here
3594 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3596 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3597 if(!isWasmInitialized) {
3598 throw new Error("initializeWasm() must be awaited first!");
3600 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3601 return nativeResponseValue;
3603 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3605 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3606 if(!isWasmInitialized) {
3607 throw new Error("initializeWasm() must be awaited first!");
3609 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3610 return nativeResponseValue;
3612 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3614 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3615 if(!isWasmInitialized) {
3616 throw new Error("initializeWasm() must be awaited first!");
3618 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3619 return nativeResponseValue;
3622 export class LDKPaymentSendFailure {
3623 protected constructor() {}
3626 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3627 if(!isWasmInitialized) {
3628 throw new Error("initializeWasm() must be awaited first!");
3630 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3631 return nativeResponseValue;
3634 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3635 if(!isWasmInitialized) {
3636 throw new Error("initializeWasm() must be awaited first!");
3638 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3639 return nativeResponseValue;
3642 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
3643 if(!isWasmInitialized) {
3644 throw new Error("initializeWasm() must be awaited first!");
3646 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3647 return nativeResponseValue;
3650 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
3651 if(!isWasmInitialized) {
3652 throw new Error("initializeWasm() must be awaited first!");
3654 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3655 return nativeResponseValue;
3658 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
3659 if(!isWasmInitialized) {
3660 throw new Error("initializeWasm() must be awaited first!");
3662 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3663 return nativeResponseValue;
3666 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
3667 if(!isWasmInitialized) {
3668 throw new Error("initializeWasm() must be awaited first!");
3670 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3671 return nativeResponseValue;
3674 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
3675 if(!isWasmInitialized) {
3676 throw new Error("initializeWasm() must be awaited first!");
3678 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3679 return nativeResponseValue;
3681 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3683 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
3684 if(!isWasmInitialized) {
3685 throw new Error("initializeWasm() must be awaited first!");
3687 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3688 return nativeResponseValue;
3690 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3692 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
3693 if(!isWasmInitialized) {
3694 throw new Error("initializeWasm() must be awaited first!");
3696 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3697 return nativeResponseValue;
3699 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3701 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
3702 if(!isWasmInitialized) {
3703 throw new Error("initializeWasm() must be awaited first!");
3705 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3706 // debug statements here
3708 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3710 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
3711 if(!isWasmInitialized) {
3712 throw new Error("initializeWasm() must be awaited first!");
3714 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3715 return nativeResponseValue;
3717 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3719 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
3720 if(!isWasmInitialized) {
3721 throw new Error("initializeWasm() must be awaited first!");
3723 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3724 return nativeResponseValue;
3726 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3728 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
3729 if(!isWasmInitialized) {
3730 throw new Error("initializeWasm() must be awaited first!");
3732 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3733 return nativeResponseValue;
3735 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3737 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
3738 if(!isWasmInitialized) {
3739 throw new Error("initializeWasm() must be awaited first!");
3741 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3742 return nativeResponseValue;
3744 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3746 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
3747 if(!isWasmInitialized) {
3748 throw new Error("initializeWasm() must be awaited first!");
3750 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3751 return nativeResponseValue;
3753 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3755 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3756 if(!isWasmInitialized) {
3757 throw new Error("initializeWasm() must be awaited first!");
3759 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3760 return nativeResponseValue;
3762 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3764 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3765 if(!isWasmInitialized) {
3766 throw new Error("initializeWasm() must be awaited first!");
3768 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3769 return nativeResponseValue;
3771 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3773 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3774 if(!isWasmInitialized) {
3775 throw new Error("initializeWasm() must be awaited first!");
3777 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3778 return nativeResponseValue;
3780 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3782 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3783 if(!isWasmInitialized) {
3784 throw new Error("initializeWasm() must be awaited first!");
3786 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3787 // debug statements here
3789 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3791 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3792 if(!isWasmInitialized) {
3793 throw new Error("initializeWasm() must be awaited first!");
3795 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3796 return nativeResponseValue;
3798 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3800 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3801 if(!isWasmInitialized) {
3802 throw new Error("initializeWasm() must be awaited first!");
3804 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3805 return nativeResponseValue;
3807 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3809 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3810 if(!isWasmInitialized) {
3811 throw new Error("initializeWasm() must be awaited first!");
3813 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3814 return nativeResponseValue;
3816 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3818 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3819 if(!isWasmInitialized) {
3820 throw new Error("initializeWasm() must be awaited first!");
3822 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3823 // debug statements here
3825 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3827 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3828 if(!isWasmInitialized) {
3829 throw new Error("initializeWasm() must be awaited first!");
3831 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3832 return nativeResponseValue;
3834 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3836 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3837 if(!isWasmInitialized) {
3838 throw new Error("initializeWasm() must be awaited first!");
3840 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3841 return nativeResponseValue;
3843 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3845 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3846 if(!isWasmInitialized) {
3847 throw new Error("initializeWasm() must be awaited first!");
3849 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3850 return nativeResponseValue;
3852 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3854 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3855 if(!isWasmInitialized) {
3856 throw new Error("initializeWasm() must be awaited first!");
3858 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3859 return nativeResponseValue;
3861 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3863 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3864 if(!isWasmInitialized) {
3865 throw new Error("initializeWasm() must be awaited first!");
3867 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3868 return nativeResponseValue;
3870 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3872 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3873 if(!isWasmInitialized) {
3874 throw new Error("initializeWasm() must be awaited first!");
3876 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3877 return nativeResponseValue;
3879 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3881 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3882 if(!isWasmInitialized) {
3883 throw new Error("initializeWasm() must be awaited first!");
3885 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3886 return nativeResponseValue;
3888 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3890 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3891 if(!isWasmInitialized) {
3892 throw new Error("initializeWasm() must be awaited first!");
3894 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3895 return nativeResponseValue;
3897 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3899 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3900 if(!isWasmInitialized) {
3901 throw new Error("initializeWasm() must be awaited first!");
3903 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3904 return nativeResponseValue;
3906 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3908 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3909 if(!isWasmInitialized) {
3910 throw new Error("initializeWasm() must be awaited first!");
3912 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3913 return nativeResponseValue;
3915 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3917 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3918 if(!isWasmInitialized) {
3919 throw new Error("initializeWasm() must be awaited first!");
3921 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3922 return nativeResponseValue;
3924 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3926 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3927 if(!isWasmInitialized) {
3928 throw new Error("initializeWasm() must be awaited first!");
3930 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3931 return nativeResponseValue;
3934 export interface LDKWatch {
3935 watch_channel (funding_txo: number, monitor: number): number;
3936 update_channel (funding_txo: number, update: number): number;
3937 release_pending_monitor_events (): number;
3941 export function LDKWatch_new(impl: LDKWatch): number {
3942 if(!isWasmInitialized) {
3943 throw new Error("initializeWasm() must be awaited first!");
3945 var new_obj_idx = js_objs.length;
3946 for (var i = 0; i < js_objs.length; i++) {
3947 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3949 js_objs[i] = new WeakRef(impl);
3950 return wasm.TS_LDKWatch_new(i);
3952 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3954 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3955 if(!isWasmInitialized) {
3956 throw new Error("initializeWasm() must be awaited first!");
3958 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3959 return nativeResponseValue;
3961 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3963 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3964 if(!isWasmInitialized) {
3965 throw new Error("initializeWasm() must be awaited first!");
3967 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3968 return nativeResponseValue;
3970 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3972 export function Watch_release_pending_monitor_events(this_arg: number): number {
3973 if(!isWasmInitialized) {
3974 throw new Error("initializeWasm() must be awaited first!");
3976 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3977 return nativeResponseValue;
3980 export interface LDKBroadcasterInterface {
3981 broadcast_transaction (tx: number): void;
3985 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3986 if(!isWasmInitialized) {
3987 throw new Error("initializeWasm() must be awaited first!");
3989 var new_obj_idx = js_objs.length;
3990 for (var i = 0; i < js_objs.length; i++) {
3991 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3993 js_objs[i] = new WeakRef(impl);
3994 return wasm.TS_LDKBroadcasterInterface_new(i);
3996 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3998 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3999 if(!isWasmInitialized) {
4000 throw new Error("initializeWasm() must be awaited first!");
4002 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4003 // debug statements here
4006 export interface LDKKeysInterface {
4007 get_node_secret (recipient: Recipient): number;
4008 get_destination_script (): number;
4009 get_shutdown_scriptpubkey (): number;
4010 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
4011 get_secure_random_bytes (): number;
4012 read_chan_signer (reader: number): number;
4013 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
4014 get_inbound_payment_key_material (): number;
4018 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
4019 if(!isWasmInitialized) {
4020 throw new Error("initializeWasm() must be awaited first!");
4022 var new_obj_idx = js_objs.length;
4023 for (var i = 0; i < js_objs.length; i++) {
4024 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4026 js_objs[i] = new WeakRef(impl);
4027 return wasm.TS_LDKKeysInterface_new(i);
4029 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4031 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
4032 if(!isWasmInitialized) {
4033 throw new Error("initializeWasm() must be awaited first!");
4035 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
4036 return nativeResponseValue;
4038 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4040 export function KeysInterface_get_destination_script(this_arg: number): number {
4041 if(!isWasmInitialized) {
4042 throw new Error("initializeWasm() must be awaited first!");
4044 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4045 return nativeResponseValue;
4047 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4049 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
4050 if(!isWasmInitialized) {
4051 throw new Error("initializeWasm() must be awaited first!");
4053 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4054 return nativeResponseValue;
4056 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4058 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
4059 if(!isWasmInitialized) {
4060 throw new Error("initializeWasm() must be awaited first!");
4062 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4063 return nativeResponseValue;
4065 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4067 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
4068 if(!isWasmInitialized) {
4069 throw new Error("initializeWasm() must be awaited first!");
4071 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4072 return nativeResponseValue;
4074 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4076 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
4077 if(!isWasmInitialized) {
4078 throw new Error("initializeWasm() must be awaited first!");
4080 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4081 return nativeResponseValue;
4083 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
4085 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
4086 if(!isWasmInitialized) {
4087 throw new Error("initializeWasm() must be awaited first!");
4089 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
4090 return nativeResponseValue;
4092 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4094 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
4095 if(!isWasmInitialized) {
4096 throw new Error("initializeWasm() must be awaited first!");
4098 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4099 return nativeResponseValue;
4102 export interface LDKFeeEstimator {
4103 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4107 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
4108 if(!isWasmInitialized) {
4109 throw new Error("initializeWasm() must be awaited first!");
4111 var new_obj_idx = js_objs.length;
4112 for (var i = 0; i < js_objs.length; i++) {
4113 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4115 js_objs[i] = new WeakRef(impl);
4116 return wasm.TS_LDKFeeEstimator_new(i);
4118 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4120 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
4121 if(!isWasmInitialized) {
4122 throw new Error("initializeWasm() must be awaited first!");
4124 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4125 return nativeResponseValue;
4127 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4129 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
4130 if(!isWasmInitialized) {
4131 throw new Error("initializeWasm() must be awaited first!");
4133 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4134 return nativeResponseValue;
4136 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4138 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
4139 if(!isWasmInitialized) {
4140 throw new Error("initializeWasm() must be awaited first!");
4142 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4143 return nativeResponseValue;
4145 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4147 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
4148 if(!isWasmInitialized) {
4149 throw new Error("initializeWasm() must be awaited first!");
4151 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4152 return nativeResponseValue;
4154 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4156 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
4157 if(!isWasmInitialized) {
4158 throw new Error("initializeWasm() must be awaited first!");
4160 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4161 return nativeResponseValue;
4163 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4165 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
4166 if(!isWasmInitialized) {
4167 throw new Error("initializeWasm() must be awaited first!");
4169 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4170 return nativeResponseValue;
4172 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4174 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
4175 if(!isWasmInitialized) {
4176 throw new Error("initializeWasm() must be awaited first!");
4178 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4179 return nativeResponseValue;
4181 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4183 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
4184 if(!isWasmInitialized) {
4185 throw new Error("initializeWasm() must be awaited first!");
4187 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
4188 return nativeResponseValue;
4190 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4192 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
4193 if(!isWasmInitialized) {
4194 throw new Error("initializeWasm() must be awaited first!");
4196 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
4197 return nativeResponseValue;
4200 export interface LDKType {
4202 debug_str (): number;
4207 export function LDKType_new(impl: LDKType): number {
4208 if(!isWasmInitialized) {
4209 throw new Error("initializeWasm() must be awaited first!");
4211 var new_obj_idx = js_objs.length;
4212 for (var i = 0; i < js_objs.length; i++) {
4213 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4215 js_objs[i] = new WeakRef(impl);
4216 return wasm.TS_LDKType_new(i);
4218 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4220 export function Type_type_id(this_arg: number): number {
4221 if(!isWasmInitialized) {
4222 throw new Error("initializeWasm() must be awaited first!");
4224 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4225 return nativeResponseValue;
4227 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4229 export function Type_debug_str(this_arg: number): number {
4230 if(!isWasmInitialized) {
4231 throw new Error("initializeWasm() must be awaited first!");
4233 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4234 return nativeResponseValue;
4236 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4238 export function Type_write(this_arg: number): number {
4239 if(!isWasmInitialized) {
4240 throw new Error("initializeWasm() must be awaited first!");
4242 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4243 return nativeResponseValue;
4246 export class LDKCOption_TypeZ {
4247 protected constructor() {}
4250 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4255 return nativeResponseValue;
4258 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
4259 if(!isWasmInitialized) {
4260 throw new Error("initializeWasm() must be awaited first!");
4262 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4263 return nativeResponseValue;
4265 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4267 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
4268 if(!isWasmInitialized) {
4269 throw new Error("initializeWasm() must be awaited first!");
4271 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4272 return nativeResponseValue;
4274 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4276 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
4277 if(!isWasmInitialized) {
4278 throw new Error("initializeWasm() must be awaited first!");
4280 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4281 return nativeResponseValue;
4284 export class LDKPaymentError {
4285 protected constructor() {}
4288 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
4289 if(!isWasmInitialized) {
4290 throw new Error("initializeWasm() must be awaited first!");
4292 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4293 return nativeResponseValue;
4296 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
4297 if(!isWasmInitialized) {
4298 throw new Error("initializeWasm() must be awaited first!");
4300 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4301 return nativeResponseValue;
4304 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
4305 if(!isWasmInitialized) {
4306 throw new Error("initializeWasm() must be awaited first!");
4308 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4309 return nativeResponseValue;
4312 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
4313 if(!isWasmInitialized) {
4314 throw new Error("initializeWasm() must be awaited first!");
4316 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4317 return nativeResponseValue;
4319 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4321 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
4322 if(!isWasmInitialized) {
4323 throw new Error("initializeWasm() must be awaited first!");
4325 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4326 return nativeResponseValue;
4328 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4330 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
4331 if(!isWasmInitialized) {
4332 throw new Error("initializeWasm() must be awaited first!");
4334 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4335 return nativeResponseValue;
4338 export class LDKParseError {
4339 protected constructor() {}
4342 export function LDKParseError_ty_from_ptr(ptr: number): number {
4343 if(!isWasmInitialized) {
4344 throw new Error("initializeWasm() must be awaited first!");
4346 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4347 return nativeResponseValue;
4350 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
4351 if(!isWasmInitialized) {
4352 throw new Error("initializeWasm() must be awaited first!");
4354 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4355 return nativeResponseValue;
4358 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
4359 if(!isWasmInitialized) {
4360 throw new Error("initializeWasm() must be awaited first!");
4362 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4363 return nativeResponseValue;
4366 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
4367 if(!isWasmInitialized) {
4368 throw new Error("initializeWasm() must be awaited first!");
4370 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4371 return nativeResponseValue;
4374 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
4375 if(!isWasmInitialized) {
4376 throw new Error("initializeWasm() must be awaited first!");
4378 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4379 return nativeResponseValue;
4382 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
4383 if(!isWasmInitialized) {
4384 throw new Error("initializeWasm() must be awaited first!");
4386 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4387 return nativeResponseValue;
4389 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4391 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
4392 if(!isWasmInitialized) {
4393 throw new Error("initializeWasm() must be awaited first!");
4395 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4396 return nativeResponseValue;
4398 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4400 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
4401 if(!isWasmInitialized) {
4402 throw new Error("initializeWasm() must be awaited first!");
4404 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4405 return nativeResponseValue;
4408 export class LDKParseOrSemanticError {
4409 protected constructor() {}
4412 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
4413 if(!isWasmInitialized) {
4414 throw new Error("initializeWasm() must be awaited first!");
4416 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4417 return nativeResponseValue;
4420 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
4421 if(!isWasmInitialized) {
4422 throw new Error("initializeWasm() must be awaited first!");
4424 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4425 return nativeResponseValue;
4428 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
4429 if(!isWasmInitialized) {
4430 throw new Error("initializeWasm() must be awaited first!");
4432 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4433 return nativeResponseValue;
4435 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4437 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
4438 if(!isWasmInitialized) {
4439 throw new Error("initializeWasm() must be awaited first!");
4441 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4442 return nativeResponseValue;
4444 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4446 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
4447 if(!isWasmInitialized) {
4448 throw new Error("initializeWasm() must be awaited first!");
4450 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4451 return nativeResponseValue;
4453 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4455 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
4456 if(!isWasmInitialized) {
4457 throw new Error("initializeWasm() must be awaited first!");
4459 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4460 return nativeResponseValue;
4462 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4464 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
4465 if(!isWasmInitialized) {
4466 throw new Error("initializeWasm() must be awaited first!");
4468 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4469 return nativeResponseValue;
4471 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4473 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
4474 if(!isWasmInitialized) {
4475 throw new Error("initializeWasm() must be awaited first!");
4477 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4478 return nativeResponseValue;
4480 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4482 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
4483 if(!isWasmInitialized) {
4484 throw new Error("initializeWasm() must be awaited first!");
4486 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4487 return nativeResponseValue;
4489 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4491 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
4492 if(!isWasmInitialized) {
4493 throw new Error("initializeWasm() must be awaited first!");
4495 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4496 return nativeResponseValue;
4498 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4500 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
4501 if(!isWasmInitialized) {
4502 throw new Error("initializeWasm() must be awaited first!");
4504 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4505 return nativeResponseValue;
4507 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4509 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
4510 if(!isWasmInitialized) {
4511 throw new Error("initializeWasm() must be awaited first!");
4513 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4514 return nativeResponseValue;
4516 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4518 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
4519 if(!isWasmInitialized) {
4520 throw new Error("initializeWasm() must be awaited first!");
4522 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4523 return nativeResponseValue;
4525 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4527 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
4528 if(!isWasmInitialized) {
4529 throw new Error("initializeWasm() must be awaited first!");
4531 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4532 return nativeResponseValue;
4534 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4536 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
4537 if(!isWasmInitialized) {
4538 throw new Error("initializeWasm() must be awaited first!");
4540 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4541 // debug statements here
4543 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4545 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
4546 if(!isWasmInitialized) {
4547 throw new Error("initializeWasm() must be awaited first!");
4549 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4550 return nativeResponseValue;
4552 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4554 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
4555 if(!isWasmInitialized) {
4556 throw new Error("initializeWasm() must be awaited first!");
4558 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4559 return nativeResponseValue;
4561 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4563 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
4564 if(!isWasmInitialized) {
4565 throw new Error("initializeWasm() must be awaited first!");
4567 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4568 return nativeResponseValue;
4570 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4572 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
4573 if(!isWasmInitialized) {
4574 throw new Error("initializeWasm() must be awaited first!");
4576 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4577 return nativeResponseValue;
4579 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4581 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
4582 if(!isWasmInitialized) {
4583 throw new Error("initializeWasm() must be awaited first!");
4585 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4586 return nativeResponseValue;
4588 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4590 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
4591 if(!isWasmInitialized) {
4592 throw new Error("initializeWasm() must be awaited first!");
4594 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4595 return nativeResponseValue;
4597 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4599 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
4600 if(!isWasmInitialized) {
4601 throw new Error("initializeWasm() must be awaited first!");
4603 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4604 return nativeResponseValue;
4606 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4608 export function CResult_StringErrorZ_get_ok(owner: number): number {
4609 if(!isWasmInitialized) {
4610 throw new Error("initializeWasm() must be awaited first!");
4612 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4613 return nativeResponseValue;
4615 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4617 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
4618 if(!isWasmInitialized) {
4619 throw new Error("initializeWasm() must be awaited first!");
4621 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4622 return nativeResponseValue;
4624 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4626 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
4627 if(!isWasmInitialized) {
4628 throw new Error("initializeWasm() must be awaited first!");
4630 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4631 return nativeResponseValue;
4633 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4635 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
4636 if(!isWasmInitialized) {
4637 throw new Error("initializeWasm() must be awaited first!");
4639 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4640 return nativeResponseValue;
4643 export class LDKCOption_MonitorEventZ {
4644 protected constructor() {}
4647 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
4648 if(!isWasmInitialized) {
4649 throw new Error("initializeWasm() must be awaited first!");
4651 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4652 return nativeResponseValue;
4655 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4656 if(!isWasmInitialized) {
4657 throw new Error("initializeWasm() must be awaited first!");
4659 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4660 return nativeResponseValue;
4662 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4664 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4665 if(!isWasmInitialized) {
4666 throw new Error("initializeWasm() must be awaited first!");
4668 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4669 return nativeResponseValue;
4671 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4673 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4674 if(!isWasmInitialized) {
4675 throw new Error("initializeWasm() must be awaited first!");
4677 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4678 return nativeResponseValue;
4680 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4682 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4683 if(!isWasmInitialized) {
4684 throw new Error("initializeWasm() must be awaited first!");
4686 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4687 return nativeResponseValue;
4689 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4691 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4692 if(!isWasmInitialized) {
4693 throw new Error("initializeWasm() must be awaited first!");
4695 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4696 return nativeResponseValue;
4698 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4700 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4701 if(!isWasmInitialized) {
4702 throw new Error("initializeWasm() must be awaited first!");
4704 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4705 return nativeResponseValue;
4707 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4709 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4710 if(!isWasmInitialized) {
4711 throw new Error("initializeWasm() must be awaited first!");
4713 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4714 return nativeResponseValue;
4716 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4718 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4719 if(!isWasmInitialized) {
4720 throw new Error("initializeWasm() must be awaited first!");
4722 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4723 return nativeResponseValue;
4725 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4727 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4728 if(!isWasmInitialized) {
4729 throw new Error("initializeWasm() must be awaited first!");
4731 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4732 return nativeResponseValue;
4734 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4736 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4737 if(!isWasmInitialized) {
4738 throw new Error("initializeWasm() must be awaited first!");
4740 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4741 return nativeResponseValue;
4743 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4745 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4746 if(!isWasmInitialized) {
4747 throw new Error("initializeWasm() must be awaited first!");
4749 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4750 return nativeResponseValue;
4752 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4754 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4755 if(!isWasmInitialized) {
4756 throw new Error("initializeWasm() must be awaited first!");
4758 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4759 return nativeResponseValue;
4761 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4763 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4764 if(!isWasmInitialized) {
4765 throw new Error("initializeWasm() must be awaited first!");
4767 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4768 return nativeResponseValue;
4770 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4772 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4773 if(!isWasmInitialized) {
4774 throw new Error("initializeWasm() must be awaited first!");
4776 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4777 return nativeResponseValue;
4779 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4781 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4782 if(!isWasmInitialized) {
4783 throw new Error("initializeWasm() must be awaited first!");
4785 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4786 return nativeResponseValue;
4789 export class LDKBalance {
4790 protected constructor() {}
4793 export function LDKBalance_ty_from_ptr(ptr: number): number {
4794 if(!isWasmInitialized) {
4795 throw new Error("initializeWasm() must be awaited first!");
4797 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4798 return nativeResponseValue;
4801 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4802 if(!isWasmInitialized) {
4803 throw new Error("initializeWasm() must be awaited first!");
4805 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4806 return nativeResponseValue;
4809 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4810 if(!isWasmInitialized) {
4811 throw new Error("initializeWasm() must be awaited first!");
4813 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4814 return nativeResponseValue;
4817 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4818 if(!isWasmInitialized) {
4819 throw new Error("initializeWasm() must be awaited first!");
4821 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4822 return nativeResponseValue;
4825 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4826 if(!isWasmInitialized) {
4827 throw new Error("initializeWasm() must be awaited first!");
4829 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4830 return nativeResponseValue;
4833 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4834 if(!isWasmInitialized) {
4835 throw new Error("initializeWasm() must be awaited first!");
4837 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4838 return nativeResponseValue;
4841 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4842 if(!isWasmInitialized) {
4843 throw new Error("initializeWasm() must be awaited first!");
4845 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4846 return nativeResponseValue;
4849 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4850 if(!isWasmInitialized) {
4851 throw new Error("initializeWasm() must be awaited first!");
4853 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4854 return nativeResponseValue;
4856 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4858 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4859 if(!isWasmInitialized) {
4860 throw new Error("initializeWasm() must be awaited first!");
4862 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4863 return nativeResponseValue;
4865 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4867 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4868 if(!isWasmInitialized) {
4869 throw new Error("initializeWasm() must be awaited first!");
4871 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4872 return nativeResponseValue;
4874 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4876 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4877 if(!isWasmInitialized) {
4878 throw new Error("initializeWasm() must be awaited first!");
4880 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4881 return nativeResponseValue;
4883 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4885 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4886 if(!isWasmInitialized) {
4887 throw new Error("initializeWasm() must be awaited first!");
4889 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4890 return nativeResponseValue;
4892 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4894 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4895 if(!isWasmInitialized) {
4896 throw new Error("initializeWasm() must be awaited first!");
4898 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4899 return nativeResponseValue;
4901 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4903 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4904 if(!isWasmInitialized) {
4905 throw new Error("initializeWasm() must be awaited first!");
4907 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4908 return nativeResponseValue;
4911 export class LDKCOption_NetAddressZ {
4912 protected constructor() {}
4915 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4916 if(!isWasmInitialized) {
4917 throw new Error("initializeWasm() must be awaited first!");
4919 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4920 return nativeResponseValue;
4923 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4924 if(!isWasmInitialized) {
4925 throw new Error("initializeWasm() must be awaited first!");
4927 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4928 return nativeResponseValue;
4930 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4932 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4933 if(!isWasmInitialized) {
4934 throw new Error("initializeWasm() must be awaited first!");
4936 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4937 return nativeResponseValue;
4939 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4941 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4942 if(!isWasmInitialized) {
4943 throw new Error("initializeWasm() must be awaited first!");
4945 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4946 return nativeResponseValue;
4948 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4950 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4951 if(!isWasmInitialized) {
4952 throw new Error("initializeWasm() must be awaited first!");
4954 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4955 // debug statements here
4957 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4959 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4960 if(!isWasmInitialized) {
4961 throw new Error("initializeWasm() must be awaited first!");
4963 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4964 return nativeResponseValue;
4966 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4968 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4969 if(!isWasmInitialized) {
4970 throw new Error("initializeWasm() must be awaited first!");
4972 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4973 return nativeResponseValue;
4975 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4977 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4978 if(!isWasmInitialized) {
4979 throw new Error("initializeWasm() must be awaited first!");
4981 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4982 return nativeResponseValue;
4984 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4986 export function CResult_NoneErrorZ_get_ok(owner: number): void {
4987 if(!isWasmInitialized) {
4988 throw new Error("initializeWasm() must be awaited first!");
4990 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4991 // debug statements here
4993 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4995 export function CResult_NoneErrorZ_get_err(owner: number): IOError {
4996 if(!isWasmInitialized) {
4997 throw new Error("initializeWasm() must be awaited first!");
4999 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
5000 return nativeResponseValue;
5002 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5004 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
5005 if(!isWasmInitialized) {
5006 throw new Error("initializeWasm() must be awaited first!");
5008 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
5009 return nativeResponseValue;
5011 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
5013 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
5014 if(!isWasmInitialized) {
5015 throw new Error("initializeWasm() must be awaited first!");
5017 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
5018 return nativeResponseValue;
5020 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5022 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
5023 if(!isWasmInitialized) {
5024 throw new Error("initializeWasm() must be awaited first!");
5026 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5027 return nativeResponseValue;
5029 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5031 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
5032 if(!isWasmInitialized) {
5033 throw new Error("initializeWasm() must be awaited first!");
5035 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5036 return nativeResponseValue;
5038 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5040 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
5041 if(!isWasmInitialized) {
5042 throw new Error("initializeWasm() must be awaited first!");
5044 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5045 return nativeResponseValue;
5047 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5049 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
5050 if(!isWasmInitialized) {
5051 throw new Error("initializeWasm() must be awaited first!");
5053 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
5054 return nativeResponseValue;
5056 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5058 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
5059 if(!isWasmInitialized) {
5060 throw new Error("initializeWasm() must be awaited first!");
5062 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
5063 return nativeResponseValue;
5065 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5067 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
5068 if(!isWasmInitialized) {
5069 throw new Error("initializeWasm() must be awaited first!");
5071 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
5072 return nativeResponseValue;
5074 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5076 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
5077 if(!isWasmInitialized) {
5078 throw new Error("initializeWasm() must be awaited first!");
5080 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
5081 return nativeResponseValue;
5083 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5085 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
5086 if(!isWasmInitialized) {
5087 throw new Error("initializeWasm() must be awaited first!");
5089 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
5090 return nativeResponseValue;
5092 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5094 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
5095 if(!isWasmInitialized) {
5096 throw new Error("initializeWasm() must be awaited first!");
5098 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
5099 return nativeResponseValue;
5101 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5103 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
5104 if(!isWasmInitialized) {
5105 throw new Error("initializeWasm() must be awaited first!");
5107 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
5108 return nativeResponseValue;
5110 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5112 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
5113 if(!isWasmInitialized) {
5114 throw new Error("initializeWasm() must be awaited first!");
5116 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
5117 return nativeResponseValue;
5119 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5121 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
5122 if(!isWasmInitialized) {
5123 throw new Error("initializeWasm() must be awaited first!");
5125 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
5126 return nativeResponseValue;
5128 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5130 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
5131 if(!isWasmInitialized) {
5132 throw new Error("initializeWasm() must be awaited first!");
5134 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
5135 return nativeResponseValue;
5137 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5139 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
5140 if(!isWasmInitialized) {
5141 throw new Error("initializeWasm() must be awaited first!");
5143 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
5144 return nativeResponseValue;
5146 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5148 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
5149 if(!isWasmInitialized) {
5150 throw new Error("initializeWasm() must be awaited first!");
5152 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
5153 return nativeResponseValue;
5155 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5157 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
5158 if(!isWasmInitialized) {
5159 throw new Error("initializeWasm() must be awaited first!");
5161 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
5162 return nativeResponseValue;
5164 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5166 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: number): number {
5167 if(!isWasmInitialized) {
5168 throw new Error("initializeWasm() must be awaited first!");
5170 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
5171 return nativeResponseValue;
5173 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5175 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: number): number {
5176 if(!isWasmInitialized) {
5177 throw new Error("initializeWasm() must be awaited first!");
5179 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
5180 return nativeResponseValue;
5182 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5184 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
5185 if(!isWasmInitialized) {
5186 throw new Error("initializeWasm() must be awaited first!");
5188 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
5189 return nativeResponseValue;
5191 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5193 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
5194 if(!isWasmInitialized) {
5195 throw new Error("initializeWasm() must be awaited first!");
5197 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
5198 return nativeResponseValue;
5200 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5202 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
5203 if(!isWasmInitialized) {
5204 throw new Error("initializeWasm() must be awaited first!");
5206 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5207 return nativeResponseValue;
5209 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5211 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
5212 if(!isWasmInitialized) {
5213 throw new Error("initializeWasm() must be awaited first!");
5215 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5216 return nativeResponseValue;
5218 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5220 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
5221 if(!isWasmInitialized) {
5222 throw new Error("initializeWasm() must be awaited first!");
5224 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5225 return nativeResponseValue;
5227 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5229 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
5230 if(!isWasmInitialized) {
5231 throw new Error("initializeWasm() must be awaited first!");
5233 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5234 return nativeResponseValue;
5236 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5238 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
5239 if(!isWasmInitialized) {
5240 throw new Error("initializeWasm() must be awaited first!");
5242 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5243 return nativeResponseValue;
5245 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5247 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
5248 if(!isWasmInitialized) {
5249 throw new Error("initializeWasm() must be awaited first!");
5251 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5252 return nativeResponseValue;
5254 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5256 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
5257 if(!isWasmInitialized) {
5258 throw new Error("initializeWasm() must be awaited first!");
5260 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5261 return nativeResponseValue;
5263 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5265 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
5266 if(!isWasmInitialized) {
5267 throw new Error("initializeWasm() must be awaited first!");
5269 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5270 return nativeResponseValue;
5272 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5274 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
5275 if(!isWasmInitialized) {
5276 throw new Error("initializeWasm() must be awaited first!");
5278 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5279 return nativeResponseValue;
5281 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5283 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
5284 if(!isWasmInitialized) {
5285 throw new Error("initializeWasm() must be awaited first!");
5287 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5288 return nativeResponseValue;
5290 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5292 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
5293 if(!isWasmInitialized) {
5294 throw new Error("initializeWasm() must be awaited first!");
5296 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5297 return nativeResponseValue;
5299 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5301 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
5302 if(!isWasmInitialized) {
5303 throw new Error("initializeWasm() must be awaited first!");
5305 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5306 return nativeResponseValue;
5308 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5310 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
5311 if(!isWasmInitialized) {
5312 throw new Error("initializeWasm() must be awaited first!");
5314 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5315 return nativeResponseValue;
5317 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5319 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
5320 if(!isWasmInitialized) {
5321 throw new Error("initializeWasm() must be awaited first!");
5323 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5324 return nativeResponseValue;
5326 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5328 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
5329 if(!isWasmInitialized) {
5330 throw new Error("initializeWasm() must be awaited first!");
5332 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5333 return nativeResponseValue;
5335 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5337 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
5338 if(!isWasmInitialized) {
5339 throw new Error("initializeWasm() must be awaited first!");
5341 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5342 return nativeResponseValue;
5344 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5346 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
5347 if(!isWasmInitialized) {
5348 throw new Error("initializeWasm() must be awaited first!");
5350 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5351 return nativeResponseValue;
5353 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5355 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
5356 if(!isWasmInitialized) {
5357 throw new Error("initializeWasm() must be awaited first!");
5359 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5360 return nativeResponseValue;
5362 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5364 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
5365 if(!isWasmInitialized) {
5366 throw new Error("initializeWasm() must be awaited first!");
5368 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5369 return nativeResponseValue;
5371 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5373 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
5374 if(!isWasmInitialized) {
5375 throw new Error("initializeWasm() must be awaited first!");
5377 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5378 return nativeResponseValue;
5380 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5382 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5383 if(!isWasmInitialized) {
5384 throw new Error("initializeWasm() must be awaited first!");
5386 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5387 return nativeResponseValue;
5389 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5391 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5392 if(!isWasmInitialized) {
5393 throw new Error("initializeWasm() must be awaited first!");
5395 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5396 return nativeResponseValue;
5398 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5400 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5401 if(!isWasmInitialized) {
5402 throw new Error("initializeWasm() must be awaited first!");
5404 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5405 return nativeResponseValue;
5407 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5409 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5410 if(!isWasmInitialized) {
5411 throw new Error("initializeWasm() must be awaited first!");
5413 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5414 return nativeResponseValue;
5416 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5418 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5419 if(!isWasmInitialized) {
5420 throw new Error("initializeWasm() must be awaited first!");
5422 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5423 return nativeResponseValue;
5425 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5427 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5428 if(!isWasmInitialized) {
5429 throw new Error("initializeWasm() must be awaited first!");
5431 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5432 return nativeResponseValue;
5434 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5436 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5437 if(!isWasmInitialized) {
5438 throw new Error("initializeWasm() must be awaited first!");
5440 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5441 return nativeResponseValue;
5443 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5445 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5446 if(!isWasmInitialized) {
5447 throw new Error("initializeWasm() must be awaited first!");
5449 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5450 return nativeResponseValue;
5452 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5454 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5455 if(!isWasmInitialized) {
5456 throw new Error("initializeWasm() must be awaited first!");
5458 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5459 return nativeResponseValue;
5461 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5463 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5464 if(!isWasmInitialized) {
5465 throw new Error("initializeWasm() must be awaited first!");
5467 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5468 return nativeResponseValue;
5470 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5472 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5473 if(!isWasmInitialized) {
5474 throw new Error("initializeWasm() must be awaited first!");
5476 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5477 return nativeResponseValue;
5479 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5481 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5482 if(!isWasmInitialized) {
5483 throw new Error("initializeWasm() must be awaited first!");
5485 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5486 return nativeResponseValue;
5488 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5490 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5491 if(!isWasmInitialized) {
5492 throw new Error("initializeWasm() must be awaited first!");
5494 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5495 return nativeResponseValue;
5497 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5499 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5500 if(!isWasmInitialized) {
5501 throw new Error("initializeWasm() must be awaited first!");
5503 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5504 return nativeResponseValue;
5506 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5508 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5509 if(!isWasmInitialized) {
5510 throw new Error("initializeWasm() must be awaited first!");
5512 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5513 return nativeResponseValue;
5515 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5517 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5518 if(!isWasmInitialized) {
5519 throw new Error("initializeWasm() must be awaited first!");
5521 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5522 return nativeResponseValue;
5524 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5526 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5527 if(!isWasmInitialized) {
5528 throw new Error("initializeWasm() must be awaited first!");
5530 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5531 return nativeResponseValue;
5533 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5535 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5536 if(!isWasmInitialized) {
5537 throw new Error("initializeWasm() must be awaited first!");
5539 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5540 return nativeResponseValue;
5542 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5544 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5545 if(!isWasmInitialized) {
5546 throw new Error("initializeWasm() must be awaited first!");
5548 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5549 return nativeResponseValue;
5551 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5553 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5554 if(!isWasmInitialized) {
5555 throw new Error("initializeWasm() must be awaited first!");
5557 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5558 return nativeResponseValue;
5560 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5562 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5563 if(!isWasmInitialized) {
5564 throw new Error("initializeWasm() must be awaited first!");
5566 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5567 return nativeResponseValue;
5569 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5571 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5572 if(!isWasmInitialized) {
5573 throw new Error("initializeWasm() must be awaited first!");
5575 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5576 return nativeResponseValue;
5578 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5580 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5581 if(!isWasmInitialized) {
5582 throw new Error("initializeWasm() must be awaited first!");
5584 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5585 return nativeResponseValue;
5587 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5589 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5590 if(!isWasmInitialized) {
5591 throw new Error("initializeWasm() must be awaited first!");
5593 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5594 return nativeResponseValue;
5596 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5598 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5599 if(!isWasmInitialized) {
5600 throw new Error("initializeWasm() must be awaited first!");
5602 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5603 return nativeResponseValue;
5605 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5607 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5608 if(!isWasmInitialized) {
5609 throw new Error("initializeWasm() must be awaited first!");
5611 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5612 return nativeResponseValue;
5615 export class LDKSignOrCreationError {
5616 protected constructor() {}
5619 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5620 if(!isWasmInitialized) {
5621 throw new Error("initializeWasm() must be awaited first!");
5623 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5624 return nativeResponseValue;
5627 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5628 if(!isWasmInitialized) {
5629 throw new Error("initializeWasm() must be awaited first!");
5631 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5632 return nativeResponseValue;
5634 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5636 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5637 if(!isWasmInitialized) {
5638 throw new Error("initializeWasm() must be awaited first!");
5640 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5641 return nativeResponseValue;
5643 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5645 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5646 if(!isWasmInitialized) {
5647 throw new Error("initializeWasm() must be awaited first!");
5649 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5650 return nativeResponseValue;
5653 export interface LDKFilter {
5654 register_tx (txid: number, script_pubkey: number): void;
5655 register_output (output: number): number;
5659 export function LDKFilter_new(impl: LDKFilter): number {
5660 if(!isWasmInitialized) {
5661 throw new Error("initializeWasm() must be awaited first!");
5663 var new_obj_idx = js_objs.length;
5664 for (var i = 0; i < js_objs.length; i++) {
5665 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5667 js_objs[i] = new WeakRef(impl);
5668 return wasm.TS_LDKFilter_new(i);
5670 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5672 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5673 if(!isWasmInitialized) {
5674 throw new Error("initializeWasm() must be awaited first!");
5676 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5677 // debug statements here
5679 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5681 export function Filter_register_output(this_arg: number, output: number): number {
5682 if(!isWasmInitialized) {
5683 throw new Error("initializeWasm() must be awaited first!");
5685 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5686 return nativeResponseValue;
5689 export class LDKCOption_FilterZ {
5690 protected constructor() {}
5693 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5694 if(!isWasmInitialized) {
5695 throw new Error("initializeWasm() must be awaited first!");
5697 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5698 return nativeResponseValue;
5701 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5702 if(!isWasmInitialized) {
5703 throw new Error("initializeWasm() must be awaited first!");
5705 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5706 return nativeResponseValue;
5708 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5710 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5711 if(!isWasmInitialized) {
5712 throw new Error("initializeWasm() must be awaited first!");
5714 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5715 return nativeResponseValue;
5717 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5719 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5720 if(!isWasmInitialized) {
5721 throw new Error("initializeWasm() must be awaited first!");
5723 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5724 // debug statements here
5727 export interface LDKMessageSendEventsProvider {
5728 get_and_clear_pending_msg_events (): number;
5732 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5733 if(!isWasmInitialized) {
5734 throw new Error("initializeWasm() must be awaited first!");
5736 var new_obj_idx = js_objs.length;
5737 for (var i = 0; i < js_objs.length; i++) {
5738 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5740 js_objs[i] = new WeakRef(impl);
5741 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5743 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5745 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5746 if(!isWasmInitialized) {
5747 throw new Error("initializeWasm() must be awaited first!");
5749 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5750 return nativeResponseValue;
5753 export interface LDKEventHandler {
5754 handle_event (event: number): void;
5758 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5759 if(!isWasmInitialized) {
5760 throw new Error("initializeWasm() must be awaited first!");
5762 var new_obj_idx = js_objs.length;
5763 for (var i = 0; i < js_objs.length; i++) {
5764 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5766 js_objs[i] = new WeakRef(impl);
5767 return wasm.TS_LDKEventHandler_new(i);
5769 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5771 export function EventHandler_handle_event(this_arg: number, event: number): void {
5772 if(!isWasmInitialized) {
5773 throw new Error("initializeWasm() must be awaited first!");
5775 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5776 // debug statements here
5779 export interface LDKEventsProvider {
5780 process_pending_events (handler: number): void;
5784 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5785 if(!isWasmInitialized) {
5786 throw new Error("initializeWasm() must be awaited first!");
5788 var new_obj_idx = js_objs.length;
5789 for (var i = 0; i < js_objs.length; i++) {
5790 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5792 js_objs[i] = new WeakRef(impl);
5793 return wasm.TS_LDKEventsProvider_new(i);
5795 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5797 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5798 if(!isWasmInitialized) {
5799 throw new Error("initializeWasm() must be awaited first!");
5801 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5802 // debug statements here
5805 export interface LDKScore {
5806 channel_penalty_msat (short_channel_id: bigint, source: number, target: number, usage: number): bigint;
5807 payment_path_failed (path: number, short_channel_id: bigint): void;
5808 payment_path_successful (path: number): void;
5809 probe_failed (path: number, short_channel_id: bigint): void;
5810 probe_successful (path: number): void;
5815 export function LDKScore_new(impl: LDKScore): number {
5816 if(!isWasmInitialized) {
5817 throw new Error("initializeWasm() must be awaited first!");
5819 var new_obj_idx = js_objs.length;
5820 for (var i = 0; i < js_objs.length; i++) {
5821 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5823 js_objs[i] = new WeakRef(impl);
5824 return wasm.TS_LDKScore_new(i);
5826 // 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
5828 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, source: number, target: number, usage: number): bigint {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5833 return nativeResponseValue;
5835 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5837 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5842 // debug statements here
5844 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5846 export function Score_payment_path_successful(this_arg: number, path: number): void {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5851 // debug statements here
5853 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5855 export function Score_probe_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
5860 // debug statements here
5862 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5864 export function Score_probe_successful(this_arg: number, path: number): void {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
5869 // debug statements here
5871 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5873 export function Score_write(this_arg: number): number {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5878 return nativeResponseValue;
5881 export interface LDKPersister {
5882 persist_manager (channel_manager: number): number;
5883 persist_graph (network_graph: number): number;
5884 persist_scorer (scorer: number): number;
5888 export function LDKPersister_new(impl: LDKPersister): number {
5889 if(!isWasmInitialized) {
5890 throw new Error("initializeWasm() must be awaited first!");
5892 var new_obj_idx = js_objs.length;
5893 for (var i = 0; i < js_objs.length; i++) {
5894 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5896 js_objs[i] = new WeakRef(impl);
5897 return wasm.TS_LDKPersister_new(i);
5899 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5901 export function Persister_persist_manager(this_arg: number, channel_manager: number): number {
5902 if(!isWasmInitialized) {
5903 throw new Error("initializeWasm() must be awaited first!");
5905 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5906 return nativeResponseValue;
5908 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5910 export function Persister_persist_graph(this_arg: number, network_graph: number): number {
5911 if(!isWasmInitialized) {
5912 throw new Error("initializeWasm() must be awaited first!");
5914 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5915 return nativeResponseValue;
5917 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5919 export function Persister_persist_scorer(this_arg: number, scorer: number): number {
5920 if(!isWasmInitialized) {
5921 throw new Error("initializeWasm() must be awaited first!");
5923 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5924 return nativeResponseValue;
5927 export interface LDKListen {
5928 filtered_block_connected (header: number, txdata: number, height: number): void;
5929 block_connected (block: number, height: number): void;
5930 block_disconnected (header: number, height: number): void;
5934 export function LDKListen_new(impl: LDKListen): number {
5935 if(!isWasmInitialized) {
5936 throw new Error("initializeWasm() must be awaited first!");
5938 var new_obj_idx = js_objs.length;
5939 for (var i = 0; i < js_objs.length; i++) {
5940 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5942 js_objs[i] = new WeakRef(impl);
5943 return wasm.TS_LDKListen_new(i);
5945 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5947 export function Listen_filtered_block_connected(this_arg: number, header: number, txdata: number, height: number): void {
5948 if(!isWasmInitialized) {
5949 throw new Error("initializeWasm() must be awaited first!");
5951 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5952 // debug statements here
5954 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5956 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5957 if(!isWasmInitialized) {
5958 throw new Error("initializeWasm() must be awaited first!");
5960 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5961 // debug statements here
5963 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5965 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5966 if(!isWasmInitialized) {
5967 throw new Error("initializeWasm() must be awaited first!");
5969 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5970 // debug statements here
5973 export interface LDKConfirm {
5974 transactions_confirmed (header: number, txdata: number, height: number): void;
5975 transaction_unconfirmed (txid: number): void;
5976 best_block_updated (header: number, height: number): void;
5977 get_relevant_txids (): number;
5981 export function LDKConfirm_new(impl: LDKConfirm): number {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 var new_obj_idx = js_objs.length;
5986 for (var i = 0; i < js_objs.length; i++) {
5987 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5989 js_objs[i] = new WeakRef(impl);
5990 return wasm.TS_LDKConfirm_new(i);
5992 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5994 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5995 if(!isWasmInitialized) {
5996 throw new Error("initializeWasm() must be awaited first!");
5998 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5999 // debug statements here
6001 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
6003 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
6004 if(!isWasmInitialized) {
6005 throw new Error("initializeWasm() must be awaited first!");
6007 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
6008 // debug statements here
6010 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
6012 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
6013 if(!isWasmInitialized) {
6014 throw new Error("initializeWasm() must be awaited first!");
6016 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
6017 // debug statements here
6019 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
6021 export function Confirm_get_relevant_txids(this_arg: number): number {
6022 if(!isWasmInitialized) {
6023 throw new Error("initializeWasm() must be awaited first!");
6025 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
6026 return nativeResponseValue;
6029 export interface LDKPersist {
6030 persist_new_channel (channel_id: number, data: number, update_id: number): number;
6031 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
6035 export function LDKPersist_new(impl: LDKPersist): number {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 var new_obj_idx = js_objs.length;
6040 for (var i = 0; i < js_objs.length; i++) {
6041 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6043 js_objs[i] = new WeakRef(impl);
6044 return wasm.TS_LDKPersist_new(i);
6046 // 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
6048 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
6049 if(!isWasmInitialized) {
6050 throw new Error("initializeWasm() must be awaited first!");
6052 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
6053 return nativeResponseValue;
6055 // 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
6057 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
6058 if(!isWasmInitialized) {
6059 throw new Error("initializeWasm() must be awaited first!");
6061 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
6062 return nativeResponseValue;
6065 export interface LDKChannelMessageHandler {
6066 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
6067 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
6068 handle_funding_created (their_node_id: number, msg: number): void;
6069 handle_funding_signed (their_node_id: number, msg: number): void;
6070 handle_channel_ready (their_node_id: number, msg: number): void;
6071 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
6072 handle_closing_signed (their_node_id: number, msg: number): void;
6073 handle_update_add_htlc (their_node_id: number, msg: number): void;
6074 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
6075 handle_update_fail_htlc (their_node_id: number, msg: number): void;
6076 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
6077 handle_commitment_signed (their_node_id: number, msg: number): void;
6078 handle_revoke_and_ack (their_node_id: number, msg: number): void;
6079 handle_update_fee (their_node_id: number, msg: number): void;
6080 handle_announcement_signatures (their_node_id: number, msg: number): void;
6081 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6082 peer_connected (their_node_id: number, msg: number): void;
6083 handle_channel_reestablish (their_node_id: number, msg: number): void;
6084 handle_channel_update (their_node_id: number, msg: number): void;
6085 handle_error (their_node_id: number, msg: number): void;
6089 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 var new_obj_idx = js_objs.length;
6094 for (var i = 0; i < js_objs.length; i++) {
6095 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6097 js_objs[i] = new WeakRef(impl);
6098 return wasm.TS_LDKChannelMessageHandler_new(i);
6100 // 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
6102 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
6103 if(!isWasmInitialized) {
6104 throw new Error("initializeWasm() must be awaited first!");
6106 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
6107 // debug statements here
6109 // 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
6111 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
6112 if(!isWasmInitialized) {
6113 throw new Error("initializeWasm() must be awaited first!");
6115 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
6116 // debug statements here
6118 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
6120 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
6121 if(!isWasmInitialized) {
6122 throw new Error("initializeWasm() must be awaited first!");
6124 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
6125 // debug statements here
6127 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
6129 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
6130 if(!isWasmInitialized) {
6131 throw new Error("initializeWasm() must be awaited first!");
6133 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
6134 // debug statements here
6136 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
6138 export function ChannelMessageHandler_handle_channel_ready(this_arg: number, their_node_id: number, msg: number): void {
6139 if(!isWasmInitialized) {
6140 throw new Error("initializeWasm() must be awaited first!");
6142 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
6143 // debug statements here
6145 // 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
6147 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
6148 if(!isWasmInitialized) {
6149 throw new Error("initializeWasm() must be awaited first!");
6151 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
6152 // debug statements here
6154 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
6156 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
6157 if(!isWasmInitialized) {
6158 throw new Error("initializeWasm() must be awaited first!");
6160 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
6161 // debug statements here
6163 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
6165 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
6166 if(!isWasmInitialized) {
6167 throw new Error("initializeWasm() must be awaited first!");
6169 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
6170 // debug statements here
6172 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
6174 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
6175 if(!isWasmInitialized) {
6176 throw new Error("initializeWasm() must be awaited first!");
6178 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
6179 // debug statements here
6181 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
6183 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
6184 if(!isWasmInitialized) {
6185 throw new Error("initializeWasm() must be awaited first!");
6187 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
6188 // debug statements here
6190 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
6192 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
6193 if(!isWasmInitialized) {
6194 throw new Error("initializeWasm() must be awaited first!");
6196 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
6197 // debug statements here
6199 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
6201 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
6202 if(!isWasmInitialized) {
6203 throw new Error("initializeWasm() must be awaited first!");
6205 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
6206 // debug statements here
6208 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
6210 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
6211 if(!isWasmInitialized) {
6212 throw new Error("initializeWasm() must be awaited first!");
6214 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
6215 // debug statements here
6217 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
6219 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
6220 if(!isWasmInitialized) {
6221 throw new Error("initializeWasm() must be awaited first!");
6223 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
6224 // debug statements here
6226 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
6228 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
6229 if(!isWasmInitialized) {
6230 throw new Error("initializeWasm() must be awaited first!");
6232 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
6233 // debug statements here
6235 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6237 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
6238 if(!isWasmInitialized) {
6239 throw new Error("initializeWasm() must be awaited first!");
6241 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6242 // debug statements here
6244 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
6246 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
6247 if(!isWasmInitialized) {
6248 throw new Error("initializeWasm() must be awaited first!");
6250 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6251 // debug statements here
6253 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6255 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
6256 if(!isWasmInitialized) {
6257 throw new Error("initializeWasm() must be awaited first!");
6259 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6260 // debug statements here
6262 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6264 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
6265 if(!isWasmInitialized) {
6266 throw new Error("initializeWasm() must be awaited first!");
6268 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6269 // debug statements here
6271 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6273 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
6274 if(!isWasmInitialized) {
6275 throw new Error("initializeWasm() must be awaited first!");
6277 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6278 // debug statements here
6281 export interface LDKRoutingMessageHandler {
6282 handle_node_announcement (msg: number): number;
6283 handle_channel_announcement (msg: number): number;
6284 handle_channel_update (msg: number): number;
6285 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
6286 get_next_node_announcements (starting_point: number, batch_amount: number): number;
6287 peer_connected (their_node_id: number, init: number): void;
6288 handle_reply_channel_range (their_node_id: number, msg: number): number;
6289 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
6290 handle_query_channel_range (their_node_id: number, msg: number): number;
6291 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
6295 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
6296 if(!isWasmInitialized) {
6297 throw new Error("initializeWasm() must be awaited first!");
6299 var new_obj_idx = js_objs.length;
6300 for (var i = 0; i < js_objs.length; i++) {
6301 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6303 js_objs[i] = new WeakRef(impl);
6304 return wasm.TS_LDKRoutingMessageHandler_new(i);
6306 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6308 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
6309 if(!isWasmInitialized) {
6310 throw new Error("initializeWasm() must be awaited first!");
6312 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6313 return nativeResponseValue;
6315 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6317 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
6318 if(!isWasmInitialized) {
6319 throw new Error("initializeWasm() must be awaited first!");
6321 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6322 return nativeResponseValue;
6324 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6326 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
6327 if(!isWasmInitialized) {
6328 throw new Error("initializeWasm() must be awaited first!");
6330 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6331 return nativeResponseValue;
6333 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6335 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
6336 if(!isWasmInitialized) {
6337 throw new Error("initializeWasm() must be awaited first!");
6339 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6340 return nativeResponseValue;
6342 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6344 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
6345 if(!isWasmInitialized) {
6346 throw new Error("initializeWasm() must be awaited first!");
6348 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6349 return nativeResponseValue;
6351 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6353 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
6354 if(!isWasmInitialized) {
6355 throw new Error("initializeWasm() must be awaited first!");
6357 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6358 // debug statements here
6360 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6362 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6363 if(!isWasmInitialized) {
6364 throw new Error("initializeWasm() must be awaited first!");
6366 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6367 return nativeResponseValue;
6369 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6371 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
6372 if(!isWasmInitialized) {
6373 throw new Error("initializeWasm() must be awaited first!");
6375 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6376 return nativeResponseValue;
6378 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6380 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6381 if(!isWasmInitialized) {
6382 throw new Error("initializeWasm() must be awaited first!");
6384 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6385 return nativeResponseValue;
6387 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6389 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
6390 if(!isWasmInitialized) {
6391 throw new Error("initializeWasm() must be awaited first!");
6393 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6394 return nativeResponseValue;
6397 export interface LDKCustomMessageReader {
6398 read (message_type: number, buffer: number): number;
6402 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
6403 if(!isWasmInitialized) {
6404 throw new Error("initializeWasm() must be awaited first!");
6406 var new_obj_idx = js_objs.length;
6407 for (var i = 0; i < js_objs.length; i++) {
6408 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6410 js_objs[i] = new WeakRef(impl);
6411 return wasm.TS_LDKCustomMessageReader_new(i);
6413 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6415 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
6416 if(!isWasmInitialized) {
6417 throw new Error("initializeWasm() must be awaited first!");
6419 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6420 return nativeResponseValue;
6423 export interface LDKCustomMessageHandler {
6424 handle_custom_message (msg: number, sender_node_id: number): number;
6425 get_and_clear_pending_msg (): number;
6429 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
6430 if(!isWasmInitialized) {
6431 throw new Error("initializeWasm() must be awaited first!");
6433 var new_obj_idx = js_objs.length;
6434 for (var i = 0; i < js_objs.length; i++) {
6435 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6437 js_objs[i] = new WeakRef(impl);
6438 return wasm.TS_LDKCustomMessageHandler_new(i);
6440 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6442 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
6443 if(!isWasmInitialized) {
6444 throw new Error("initializeWasm() must be awaited first!");
6446 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6447 return nativeResponseValue;
6449 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6451 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
6452 if(!isWasmInitialized) {
6453 throw new Error("initializeWasm() must be awaited first!");
6455 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6456 return nativeResponseValue;
6459 export interface LDKSocketDescriptor {
6460 send_data (data: number, resume_read: boolean): number;
6461 disconnect_socket (): void;
6462 eq (other_arg: number): boolean;
6467 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
6468 if(!isWasmInitialized) {
6469 throw new Error("initializeWasm() must be awaited first!");
6471 var new_obj_idx = js_objs.length;
6472 for (var i = 0; i < js_objs.length; i++) {
6473 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6475 js_objs[i] = new WeakRef(impl);
6476 return wasm.TS_LDKSocketDescriptor_new(i);
6478 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6480 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
6481 if(!isWasmInitialized) {
6482 throw new Error("initializeWasm() must be awaited first!");
6484 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6485 return nativeResponseValue;
6487 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6489 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
6490 if(!isWasmInitialized) {
6491 throw new Error("initializeWasm() must be awaited first!");
6493 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6494 // debug statements here
6496 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6498 export function SocketDescriptor_hash(this_arg: number): bigint {
6499 if(!isWasmInitialized) {
6500 throw new Error("initializeWasm() must be awaited first!");
6502 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6503 return nativeResponseValue;
6506 export class LDKEffectiveCapacity {
6507 protected constructor() {}
6510 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
6511 if(!isWasmInitialized) {
6512 throw new Error("initializeWasm() must be awaited first!");
6514 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6515 return nativeResponseValue;
6518 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
6519 if(!isWasmInitialized) {
6520 throw new Error("initializeWasm() must be awaited first!");
6522 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6523 return nativeResponseValue;
6526 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6527 if(!isWasmInitialized) {
6528 throw new Error("initializeWasm() must be awaited first!");
6530 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6531 return nativeResponseValue;
6534 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6535 if(!isWasmInitialized) {
6536 throw new Error("initializeWasm() must be awaited first!");
6538 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6539 return nativeResponseValue;
6542 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: number): number {
6543 if(!isWasmInitialized) {
6544 throw new Error("initializeWasm() must be awaited first!");
6546 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
6547 return nativeResponseValue;
6550 export interface LDKLockableScore {
6555 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6556 if(!isWasmInitialized) {
6557 throw new Error("initializeWasm() must be awaited first!");
6559 var new_obj_idx = js_objs.length;
6560 for (var i = 0; i < js_objs.length; i++) {
6561 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6563 js_objs[i] = new WeakRef(impl);
6564 return wasm.TS_LDKLockableScore_new(i);
6566 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6568 export function LockableScore_lock(this_arg: number): number {
6569 if(!isWasmInitialized) {
6570 throw new Error("initializeWasm() must be awaited first!");
6572 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6573 return nativeResponseValue;
6576 export class LDKFallback {
6577 protected constructor() {}
6580 export function LDKFallback_ty_from_ptr(ptr: number): number {
6581 if(!isWasmInitialized) {
6582 throw new Error("initializeWasm() must be awaited first!");
6584 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6585 return nativeResponseValue;
6588 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6589 if(!isWasmInitialized) {
6590 throw new Error("initializeWasm() must be awaited first!");
6592 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6593 return nativeResponseValue;
6596 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6597 if(!isWasmInitialized) {
6598 throw new Error("initializeWasm() must be awaited first!");
6600 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6601 return nativeResponseValue;
6604 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6605 if(!isWasmInitialized) {
6606 throw new Error("initializeWasm() must be awaited first!");
6608 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6609 return nativeResponseValue;
6612 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6613 if(!isWasmInitialized) {
6614 throw new Error("initializeWasm() must be awaited first!");
6616 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6617 return nativeResponseValue;
6620 export interface LDKPayer {
6622 first_hops (): number;
6623 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6624 send_spontaneous_payment (route: number, payment_preimage: number): number;
6625 retry_payment (route: number, payment_id: number): number;
6626 abandon_payment (payment_id: number): void;
6630 export function LDKPayer_new(impl: LDKPayer): number {
6631 if(!isWasmInitialized) {
6632 throw new Error("initializeWasm() must be awaited first!");
6634 var new_obj_idx = js_objs.length;
6635 for (var i = 0; i < js_objs.length; i++) {
6636 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6638 js_objs[i] = new WeakRef(impl);
6639 return wasm.TS_LDKPayer_new(i);
6641 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6643 export function Payer_node_id(this_arg: number): number {
6644 if(!isWasmInitialized) {
6645 throw new Error("initializeWasm() must be awaited first!");
6647 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6648 return nativeResponseValue;
6650 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6652 export function Payer_first_hops(this_arg: number): number {
6653 if(!isWasmInitialized) {
6654 throw new Error("initializeWasm() must be awaited first!");
6656 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6657 return nativeResponseValue;
6659 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6661 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6662 if(!isWasmInitialized) {
6663 throw new Error("initializeWasm() must be awaited first!");
6665 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6666 return nativeResponseValue;
6668 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6670 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6671 if(!isWasmInitialized) {
6672 throw new Error("initializeWasm() must be awaited first!");
6674 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6675 return nativeResponseValue;
6677 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6679 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6680 if(!isWasmInitialized) {
6681 throw new Error("initializeWasm() must be awaited first!");
6683 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6684 return nativeResponseValue;
6686 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6688 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6689 if(!isWasmInitialized) {
6690 throw new Error("initializeWasm() must be awaited first!");
6692 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6693 // debug statements here
6696 export interface LDKRouter {
6697 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6701 export function LDKRouter_new(impl: LDKRouter): number {
6702 if(!isWasmInitialized) {
6703 throw new Error("initializeWasm() must be awaited first!");
6705 var new_obj_idx = js_objs.length;
6706 for (var i = 0; i < js_objs.length; i++) {
6707 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6709 js_objs[i] = new WeakRef(impl);
6710 return wasm.TS_LDKRouter_new(i);
6712 // 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
6714 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6715 if(!isWasmInitialized) {
6716 throw new Error("initializeWasm() must be awaited first!");
6718 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6719 return nativeResponseValue;
6722 export class LDKRetry {
6723 protected constructor() {}
6726 export function LDKRetry_ty_from_ptr(ptr: number): number {
6727 if(!isWasmInitialized) {
6728 throw new Error("initializeWasm() must be awaited first!");
6730 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6731 return nativeResponseValue;
6734 export function LDKRetry_Attempts_get_attempts(ptr: number): number {
6735 if(!isWasmInitialized) {
6736 throw new Error("initializeWasm() must be awaited first!");
6738 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6739 return nativeResponseValue;
6741 // struct LDKStr _ldk_get_compiled_version(void);
6743 export function _ldk_get_compiled_version(): number {
6744 if(!isWasmInitialized) {
6745 throw new Error("initializeWasm() must be awaited first!");
6747 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6748 return nativeResponseValue;
6750 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6752 export function _ldk_c_bindings_get_compiled_version(): number {
6753 if(!isWasmInitialized) {
6754 throw new Error("initializeWasm() must be awaited first!");
6756 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6757 return nativeResponseValue;
6759 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6761 export function Bech32Error_clone_ptr(arg: number): number {
6762 if(!isWasmInitialized) {
6763 throw new Error("initializeWasm() must be awaited first!");
6765 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6766 return nativeResponseValue;
6768 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6770 export function Bech32Error_clone(orig: number): number {
6771 if(!isWasmInitialized) {
6772 throw new Error("initializeWasm() must be awaited first!");
6774 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6775 return nativeResponseValue;
6777 // void Bech32Error_free(struct LDKBech32Error o);
6779 export function Bech32Error_free(o: number): void {
6780 if(!isWasmInitialized) {
6781 throw new Error("initializeWasm() must be awaited first!");
6783 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6784 // debug statements here
6786 // void Transaction_free(struct LDKTransaction _res);
6788 export function Transaction_free(_res: number): void {
6789 if(!isWasmInitialized) {
6790 throw new Error("initializeWasm() must be awaited first!");
6792 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6793 // debug statements here
6795 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6797 export function TxOut_new(script_pubkey: number, value: bigint): number {
6798 if(!isWasmInitialized) {
6799 throw new Error("initializeWasm() must be awaited first!");
6801 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6802 return nativeResponseValue;
6804 // void TxOut_free(struct LDKTxOut _res);
6806 export function TxOut_free(_res: number): void {
6807 if(!isWasmInitialized) {
6808 throw new Error("initializeWasm() must be awaited first!");
6810 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6811 // debug statements here
6813 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6815 export function TxOut_clone_ptr(arg: number): number {
6816 if(!isWasmInitialized) {
6817 throw new Error("initializeWasm() must be awaited first!");
6819 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6820 return nativeResponseValue;
6822 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6824 export function TxOut_clone(orig: number): number {
6825 if(!isWasmInitialized) {
6826 throw new Error("initializeWasm() must be awaited first!");
6828 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6829 return nativeResponseValue;
6831 // void Str_free(struct LDKStr _res);
6833 export function Str_free(_res: number): void {
6834 if(!isWasmInitialized) {
6835 throw new Error("initializeWasm() must be awaited first!");
6837 const nativeResponseValue = wasm.TS_Str_free(_res);
6838 // debug statements here
6840 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6842 export function CResult_NoneNoneZ_ok(): number {
6843 if(!isWasmInitialized) {
6844 throw new Error("initializeWasm() must be awaited first!");
6846 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6847 return nativeResponseValue;
6849 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6851 export function CResult_NoneNoneZ_err(): number {
6852 if(!isWasmInitialized) {
6853 throw new Error("initializeWasm() must be awaited first!");
6855 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6856 return nativeResponseValue;
6858 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6860 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6861 if(!isWasmInitialized) {
6862 throw new Error("initializeWasm() must be awaited first!");
6864 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6865 return nativeResponseValue;
6867 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6869 export function CResult_NoneNoneZ_free(_res: number): void {
6870 if(!isWasmInitialized) {
6871 throw new Error("initializeWasm() must be awaited first!");
6873 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6874 // debug statements here
6876 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6878 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6879 if(!isWasmInitialized) {
6880 throw new Error("initializeWasm() must be awaited first!");
6882 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6883 return nativeResponseValue;
6885 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6887 export function CResult_NoneNoneZ_clone(orig: number): number {
6888 if(!isWasmInitialized) {
6889 throw new Error("initializeWasm() must be awaited first!");
6891 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6892 return nativeResponseValue;
6894 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6896 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6897 if(!isWasmInitialized) {
6898 throw new Error("initializeWasm() must be awaited first!");
6900 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6901 return nativeResponseValue;
6903 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6905 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6906 if(!isWasmInitialized) {
6907 throw new Error("initializeWasm() must be awaited first!");
6909 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6910 return nativeResponseValue;
6912 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6914 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6915 if(!isWasmInitialized) {
6916 throw new Error("initializeWasm() must be awaited first!");
6918 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6919 return nativeResponseValue;
6921 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6923 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6924 if(!isWasmInitialized) {
6925 throw new Error("initializeWasm() must be awaited first!");
6927 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6928 // debug statements here
6930 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6932 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6933 if(!isWasmInitialized) {
6934 throw new Error("initializeWasm() must be awaited first!");
6936 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6937 return nativeResponseValue;
6939 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6941 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6942 if(!isWasmInitialized) {
6943 throw new Error("initializeWasm() must be awaited first!");
6945 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6946 return nativeResponseValue;
6948 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6950 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6951 if(!isWasmInitialized) {
6952 throw new Error("initializeWasm() must be awaited first!");
6954 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6955 return nativeResponseValue;
6957 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6959 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6960 if(!isWasmInitialized) {
6961 throw new Error("initializeWasm() must be awaited first!");
6963 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6964 return nativeResponseValue;
6966 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6968 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6969 if(!isWasmInitialized) {
6970 throw new Error("initializeWasm() must be awaited first!");
6972 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6973 return nativeResponseValue;
6975 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6977 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6978 if(!isWasmInitialized) {
6979 throw new Error("initializeWasm() must be awaited first!");
6981 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6982 // debug statements here
6984 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6986 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6987 if(!isWasmInitialized) {
6988 throw new Error("initializeWasm() must be awaited first!");
6990 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6991 return nativeResponseValue;
6993 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6995 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6996 if(!isWasmInitialized) {
6997 throw new Error("initializeWasm() must be awaited first!");
6999 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
7000 return nativeResponseValue;
7002 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
7004 export function CResult_PublicKeyErrorZ_ok(o: number): number {
7005 if(!isWasmInitialized) {
7006 throw new Error("initializeWasm() must be awaited first!");
7008 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
7009 return nativeResponseValue;
7011 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
7013 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
7014 if(!isWasmInitialized) {
7015 throw new Error("initializeWasm() must be awaited first!");
7017 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
7018 return nativeResponseValue;
7020 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
7022 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
7023 if(!isWasmInitialized) {
7024 throw new Error("initializeWasm() must be awaited first!");
7026 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
7027 return nativeResponseValue;
7029 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
7031 export function CResult_PublicKeyErrorZ_free(_res: number): void {
7032 if(!isWasmInitialized) {
7033 throw new Error("initializeWasm() must be awaited first!");
7035 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
7036 // debug statements here
7038 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
7040 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
7041 if(!isWasmInitialized) {
7042 throw new Error("initializeWasm() must be awaited first!");
7044 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
7045 return nativeResponseValue;
7047 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
7049 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
7050 if(!isWasmInitialized) {
7051 throw new Error("initializeWasm() must be awaited first!");
7053 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
7054 return nativeResponseValue;
7056 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
7058 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
7059 if(!isWasmInitialized) {
7060 throw new Error("initializeWasm() must be awaited first!");
7062 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
7063 return nativeResponseValue;
7065 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
7067 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
7068 if(!isWasmInitialized) {
7069 throw new Error("initializeWasm() must be awaited first!");
7071 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
7072 return nativeResponseValue;
7074 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
7076 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
7077 if(!isWasmInitialized) {
7078 throw new Error("initializeWasm() must be awaited first!");
7080 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
7081 return nativeResponseValue;
7083 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
7085 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
7086 if(!isWasmInitialized) {
7087 throw new Error("initializeWasm() must be awaited first!");
7089 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
7090 // debug statements here
7092 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
7094 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
7095 if(!isWasmInitialized) {
7096 throw new Error("initializeWasm() must be awaited first!");
7098 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
7099 return nativeResponseValue;
7101 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
7103 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
7104 if(!isWasmInitialized) {
7105 throw new Error("initializeWasm() must be awaited first!");
7107 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
7108 return nativeResponseValue;
7110 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
7112 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
7113 if(!isWasmInitialized) {
7114 throw new Error("initializeWasm() must be awaited first!");
7116 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
7117 return nativeResponseValue;
7119 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
7121 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
7122 if(!isWasmInitialized) {
7123 throw new Error("initializeWasm() must be awaited first!");
7125 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
7126 return nativeResponseValue;
7128 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
7130 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
7131 if(!isWasmInitialized) {
7132 throw new Error("initializeWasm() must be awaited first!");
7134 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
7135 return nativeResponseValue;
7137 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
7139 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
7140 if(!isWasmInitialized) {
7141 throw new Error("initializeWasm() must be awaited first!");
7143 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
7144 // debug statements here
7146 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
7148 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
7149 if(!isWasmInitialized) {
7150 throw new Error("initializeWasm() must be awaited first!");
7152 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
7153 return nativeResponseValue;
7155 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
7157 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
7158 if(!isWasmInitialized) {
7159 throw new Error("initializeWasm() must be awaited first!");
7161 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
7162 return nativeResponseValue;
7164 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
7166 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
7167 if(!isWasmInitialized) {
7168 throw new Error("initializeWasm() must be awaited first!");
7170 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
7171 return nativeResponseValue;
7173 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
7175 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
7176 if(!isWasmInitialized) {
7177 throw new Error("initializeWasm() must be awaited first!");
7179 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
7180 return nativeResponseValue;
7182 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
7184 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
7185 if(!isWasmInitialized) {
7186 throw new Error("initializeWasm() must be awaited first!");
7188 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
7189 return nativeResponseValue;
7191 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
7193 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
7194 if(!isWasmInitialized) {
7195 throw new Error("initializeWasm() must be awaited first!");
7197 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
7198 // debug statements here
7200 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
7202 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
7203 if(!isWasmInitialized) {
7204 throw new Error("initializeWasm() must be awaited first!");
7206 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
7207 return nativeResponseValue;
7209 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
7211 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
7212 if(!isWasmInitialized) {
7213 throw new Error("initializeWasm() must be awaited first!");
7215 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
7216 return nativeResponseValue;
7218 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
7220 export function COption_u32Z_some(o: number): number {
7221 if(!isWasmInitialized) {
7222 throw new Error("initializeWasm() must be awaited first!");
7224 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
7225 return nativeResponseValue;
7227 // struct LDKCOption_u32Z COption_u32Z_none(void);
7229 export function COption_u32Z_none(): number {
7230 if(!isWasmInitialized) {
7231 throw new Error("initializeWasm() must be awaited first!");
7233 const nativeResponseValue = wasm.TS_COption_u32Z_none();
7234 return nativeResponseValue;
7236 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
7238 export function COption_u32Z_free(_res: number): void {
7239 if(!isWasmInitialized) {
7240 throw new Error("initializeWasm() must be awaited first!");
7242 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
7243 // debug statements here
7245 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
7247 export function COption_u32Z_clone_ptr(arg: number): number {
7248 if(!isWasmInitialized) {
7249 throw new Error("initializeWasm() must be awaited first!");
7251 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
7252 return nativeResponseValue;
7254 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
7256 export function COption_u32Z_clone(orig: number): number {
7257 if(!isWasmInitialized) {
7258 throw new Error("initializeWasm() must be awaited first!");
7260 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
7261 return nativeResponseValue;
7263 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
7265 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
7266 if(!isWasmInitialized) {
7267 throw new Error("initializeWasm() must be awaited first!");
7269 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
7270 return nativeResponseValue;
7272 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
7274 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
7275 if(!isWasmInitialized) {
7276 throw new Error("initializeWasm() must be awaited first!");
7278 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
7279 return nativeResponseValue;
7281 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
7283 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
7284 if(!isWasmInitialized) {
7285 throw new Error("initializeWasm() must be awaited first!");
7287 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
7288 return nativeResponseValue;
7290 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
7292 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
7293 if(!isWasmInitialized) {
7294 throw new Error("initializeWasm() must be awaited first!");
7296 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
7297 // debug statements here
7299 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
7301 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
7302 if(!isWasmInitialized) {
7303 throw new Error("initializeWasm() must be awaited first!");
7305 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
7306 return nativeResponseValue;
7308 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
7310 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
7311 if(!isWasmInitialized) {
7312 throw new Error("initializeWasm() must be awaited first!");
7314 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7315 return nativeResponseValue;
7317 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7319 export function COption_NoneZ_some(): COption_NoneZ {
7320 if(!isWasmInitialized) {
7321 throw new Error("initializeWasm() must be awaited first!");
7323 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7324 return nativeResponseValue;
7326 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7328 export function COption_NoneZ_none(): COption_NoneZ {
7329 if(!isWasmInitialized) {
7330 throw new Error("initializeWasm() must be awaited first!");
7332 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7333 return nativeResponseValue;
7335 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7337 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7338 if(!isWasmInitialized) {
7339 throw new Error("initializeWasm() must be awaited first!");
7341 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7342 // debug statements here
7344 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7346 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7347 if(!isWasmInitialized) {
7348 throw new Error("initializeWasm() must be awaited first!");
7350 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7351 return nativeResponseValue;
7353 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7355 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7356 if(!isWasmInitialized) {
7357 throw new Error("initializeWasm() must be awaited first!");
7359 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7360 return nativeResponseValue;
7362 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7364 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7365 if(!isWasmInitialized) {
7366 throw new Error("initializeWasm() must be awaited first!");
7368 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7369 return nativeResponseValue;
7371 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7373 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7374 if(!isWasmInitialized) {
7375 throw new Error("initializeWasm() must be awaited first!");
7377 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7378 // debug statements here
7380 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7382 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7383 if(!isWasmInitialized) {
7384 throw new Error("initializeWasm() must be awaited first!");
7386 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7387 return nativeResponseValue;
7389 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7391 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7392 if(!isWasmInitialized) {
7393 throw new Error("initializeWasm() must be awaited first!");
7395 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7396 return nativeResponseValue;
7398 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7400 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7401 if(!isWasmInitialized) {
7402 throw new Error("initializeWasm() must be awaited first!");
7404 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7405 return nativeResponseValue;
7407 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7409 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7410 if(!isWasmInitialized) {
7411 throw new Error("initializeWasm() must be awaited first!");
7413 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7414 return nativeResponseValue;
7416 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7418 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7419 if(!isWasmInitialized) {
7420 throw new Error("initializeWasm() must be awaited first!");
7422 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7423 return nativeResponseValue;
7425 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7427 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7428 if(!isWasmInitialized) {
7429 throw new Error("initializeWasm() must be awaited first!");
7431 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7432 // debug statements here
7434 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7436 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7437 if(!isWasmInitialized) {
7438 throw new Error("initializeWasm() must be awaited first!");
7440 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7441 return nativeResponseValue;
7443 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7445 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7446 if(!isWasmInitialized) {
7447 throw new Error("initializeWasm() must be awaited first!");
7449 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7450 return nativeResponseValue;
7452 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7454 export function CVec_SignatureZ_free(_res: number): void {
7455 if(!isWasmInitialized) {
7456 throw new Error("initializeWasm() must be awaited first!");
7458 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7459 // debug statements here
7461 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7463 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7464 if(!isWasmInitialized) {
7465 throw new Error("initializeWasm() must be awaited first!");
7467 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7468 return nativeResponseValue;
7470 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7472 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
7473 if(!isWasmInitialized) {
7474 throw new Error("initializeWasm() must be awaited first!");
7476 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7477 return nativeResponseValue;
7479 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7481 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7482 if(!isWasmInitialized) {
7483 throw new Error("initializeWasm() must be awaited first!");
7485 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7486 return nativeResponseValue;
7488 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7490 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7491 if(!isWasmInitialized) {
7492 throw new Error("initializeWasm() must be awaited first!");
7494 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7495 // debug statements here
7497 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7499 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7500 if(!isWasmInitialized) {
7501 throw new Error("initializeWasm() must be awaited first!");
7503 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7504 return nativeResponseValue;
7506 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7508 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7509 if(!isWasmInitialized) {
7510 throw new Error("initializeWasm() must be awaited first!");
7512 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7513 return nativeResponseValue;
7515 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7517 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7518 if(!isWasmInitialized) {
7519 throw new Error("initializeWasm() must be awaited first!");
7521 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7522 return nativeResponseValue;
7524 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7526 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7527 if(!isWasmInitialized) {
7528 throw new Error("initializeWasm() must be awaited first!");
7530 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7531 return nativeResponseValue;
7533 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7535 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7536 if(!isWasmInitialized) {
7537 throw new Error("initializeWasm() must be awaited first!");
7539 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7540 return nativeResponseValue;
7542 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7544 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7545 if(!isWasmInitialized) {
7546 throw new Error("initializeWasm() must be awaited first!");
7548 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7549 // debug statements here
7551 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7553 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7554 if(!isWasmInitialized) {
7555 throw new Error("initializeWasm() must be awaited first!");
7557 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7558 return nativeResponseValue;
7560 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7562 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7563 if(!isWasmInitialized) {
7564 throw new Error("initializeWasm() must be awaited first!");
7566 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7567 return nativeResponseValue;
7569 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7571 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7572 if(!isWasmInitialized) {
7573 throw new Error("initializeWasm() must be awaited first!");
7575 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7576 return nativeResponseValue;
7578 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7580 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7581 if(!isWasmInitialized) {
7582 throw new Error("initializeWasm() must be awaited first!");
7584 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7585 return nativeResponseValue;
7587 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7589 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7590 if(!isWasmInitialized) {
7591 throw new Error("initializeWasm() must be awaited first!");
7593 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7594 return nativeResponseValue;
7596 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7598 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7599 if(!isWasmInitialized) {
7600 throw new Error("initializeWasm() must be awaited first!");
7602 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7603 // debug statements here
7605 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7607 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7608 if(!isWasmInitialized) {
7609 throw new Error("initializeWasm() must be awaited first!");
7611 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7612 return nativeResponseValue;
7614 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7616 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7617 if(!isWasmInitialized) {
7618 throw new Error("initializeWasm() must be awaited first!");
7620 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7621 return nativeResponseValue;
7623 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7625 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7626 if(!isWasmInitialized) {
7627 throw new Error("initializeWasm() must be awaited first!");
7629 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7630 return nativeResponseValue;
7632 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7634 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7635 if(!isWasmInitialized) {
7636 throw new Error("initializeWasm() must be awaited first!");
7638 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7639 // debug statements here
7641 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7643 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7644 if(!isWasmInitialized) {
7645 throw new Error("initializeWasm() must be awaited first!");
7647 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7648 return nativeResponseValue;
7650 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7652 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7653 if(!isWasmInitialized) {
7654 throw new Error("initializeWasm() must be awaited first!");
7656 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7657 return nativeResponseValue;
7659 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7661 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7662 if(!isWasmInitialized) {
7663 throw new Error("initializeWasm() must be awaited first!");
7665 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7666 return nativeResponseValue;
7668 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7670 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7671 if(!isWasmInitialized) {
7672 throw new Error("initializeWasm() must be awaited first!");
7674 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7675 return nativeResponseValue;
7677 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7679 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7680 if(!isWasmInitialized) {
7681 throw new Error("initializeWasm() must be awaited first!");
7683 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7684 return nativeResponseValue;
7686 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7688 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7689 if(!isWasmInitialized) {
7690 throw new Error("initializeWasm() must be awaited first!");
7692 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7693 // debug statements here
7695 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7697 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7698 if(!isWasmInitialized) {
7699 throw new Error("initializeWasm() must be awaited first!");
7701 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7702 return nativeResponseValue;
7704 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7706 export function CResult_CVec_SignatureZNoneZ_err(): number {
7707 if(!isWasmInitialized) {
7708 throw new Error("initializeWasm() must be awaited first!");
7710 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7711 return nativeResponseValue;
7713 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7715 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7716 if(!isWasmInitialized) {
7717 throw new Error("initializeWasm() must be awaited first!");
7719 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7720 return nativeResponseValue;
7722 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7724 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7725 if(!isWasmInitialized) {
7726 throw new Error("initializeWasm() must be awaited first!");
7728 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7729 // debug statements here
7731 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7733 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7734 if(!isWasmInitialized) {
7735 throw new Error("initializeWasm() must be awaited first!");
7737 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7738 return nativeResponseValue;
7740 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7742 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7743 if(!isWasmInitialized) {
7744 throw new Error("initializeWasm() must be awaited first!");
7746 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7747 return nativeResponseValue;
7749 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7751 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7752 if(!isWasmInitialized) {
7753 throw new Error("initializeWasm() must be awaited first!");
7755 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7756 return nativeResponseValue;
7758 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7760 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7761 if(!isWasmInitialized) {
7762 throw new Error("initializeWasm() must be awaited first!");
7764 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7765 return nativeResponseValue;
7767 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7769 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7770 if(!isWasmInitialized) {
7771 throw new Error("initializeWasm() must be awaited first!");
7773 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7774 return nativeResponseValue;
7776 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7778 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7779 if(!isWasmInitialized) {
7780 throw new Error("initializeWasm() must be awaited first!");
7782 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7783 // debug statements here
7785 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7787 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7788 if(!isWasmInitialized) {
7789 throw new Error("initializeWasm() must be awaited first!");
7791 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7792 return nativeResponseValue;
7794 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7796 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7797 if(!isWasmInitialized) {
7798 throw new Error("initializeWasm() must be awaited first!");
7800 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7801 return nativeResponseValue;
7803 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7805 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7806 if(!isWasmInitialized) {
7807 throw new Error("initializeWasm() must be awaited first!");
7809 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7810 return nativeResponseValue;
7812 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7814 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7815 if(!isWasmInitialized) {
7816 throw new Error("initializeWasm() must be awaited first!");
7818 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7819 return nativeResponseValue;
7821 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7823 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7824 if(!isWasmInitialized) {
7825 throw new Error("initializeWasm() must be awaited first!");
7827 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7828 return nativeResponseValue;
7830 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7832 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7833 if(!isWasmInitialized) {
7834 throw new Error("initializeWasm() must be awaited first!");
7836 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7837 // debug statements here
7839 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7841 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7842 if(!isWasmInitialized) {
7843 throw new Error("initializeWasm() must be awaited first!");
7845 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7846 return nativeResponseValue;
7848 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7850 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7851 if(!isWasmInitialized) {
7852 throw new Error("initializeWasm() must be awaited first!");
7854 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7855 return nativeResponseValue;
7857 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7859 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7860 if(!isWasmInitialized) {
7861 throw new Error("initializeWasm() must be awaited first!");
7863 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7864 return nativeResponseValue;
7866 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7868 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7869 if(!isWasmInitialized) {
7870 throw new Error("initializeWasm() must be awaited first!");
7872 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7873 return nativeResponseValue;
7875 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7877 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7878 if(!isWasmInitialized) {
7879 throw new Error("initializeWasm() must be awaited first!");
7881 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7882 return nativeResponseValue;
7884 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7886 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7887 if(!isWasmInitialized) {
7888 throw new Error("initializeWasm() must be awaited first!");
7890 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7891 // debug statements here
7893 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7895 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7896 if(!isWasmInitialized) {
7897 throw new Error("initializeWasm() must be awaited first!");
7899 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7900 return nativeResponseValue;
7902 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7904 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7905 if(!isWasmInitialized) {
7906 throw new Error("initializeWasm() must be awaited first!");
7908 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7909 return nativeResponseValue;
7911 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7913 export function CVec_RouteHopZ_free(_res: number): void {
7914 if(!isWasmInitialized) {
7915 throw new Error("initializeWasm() must be awaited first!");
7917 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7918 // debug statements here
7920 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7922 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7923 if(!isWasmInitialized) {
7924 throw new Error("initializeWasm() must be awaited first!");
7926 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7927 // debug statements here
7929 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7931 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7932 if(!isWasmInitialized) {
7933 throw new Error("initializeWasm() must be awaited first!");
7935 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7936 return nativeResponseValue;
7938 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7940 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7941 if(!isWasmInitialized) {
7942 throw new Error("initializeWasm() must be awaited first!");
7944 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7945 return nativeResponseValue;
7947 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7949 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7950 if(!isWasmInitialized) {
7951 throw new Error("initializeWasm() must be awaited first!");
7953 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7954 return nativeResponseValue;
7956 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7958 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7959 if(!isWasmInitialized) {
7960 throw new Error("initializeWasm() must be awaited first!");
7962 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7963 // debug statements here
7965 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7967 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7968 if(!isWasmInitialized) {
7969 throw new Error("initializeWasm() must be awaited first!");
7971 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7972 return nativeResponseValue;
7974 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7976 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7977 if(!isWasmInitialized) {
7978 throw new Error("initializeWasm() must be awaited first!");
7980 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7981 return nativeResponseValue;
7983 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7985 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7986 if(!isWasmInitialized) {
7987 throw new Error("initializeWasm() must be awaited first!");
7989 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7990 return nativeResponseValue;
7992 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7994 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7995 if(!isWasmInitialized) {
7996 throw new Error("initializeWasm() must be awaited first!");
7998 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7999 return nativeResponseValue;
8001 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
8003 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
8004 if(!isWasmInitialized) {
8005 throw new Error("initializeWasm() must be awaited first!");
8007 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
8008 return nativeResponseValue;
8010 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
8012 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
8013 if(!isWasmInitialized) {
8014 throw new Error("initializeWasm() must be awaited first!");
8016 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
8017 // debug statements here
8019 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
8021 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
8022 if(!isWasmInitialized) {
8023 throw new Error("initializeWasm() must be awaited first!");
8025 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
8026 return nativeResponseValue;
8028 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
8030 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
8031 if(!isWasmInitialized) {
8032 throw new Error("initializeWasm() must be awaited first!");
8034 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
8035 return nativeResponseValue;
8037 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
8039 export function CVec_RouteHintZ_free(_res: number): void {
8040 if(!isWasmInitialized) {
8041 throw new Error("initializeWasm() must be awaited first!");
8043 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
8044 // debug statements here
8046 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
8048 export function COption_u64Z_some(o: bigint): number {
8049 if(!isWasmInitialized) {
8050 throw new Error("initializeWasm() must be awaited first!");
8052 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
8053 return nativeResponseValue;
8055 // struct LDKCOption_u64Z COption_u64Z_none(void);
8057 export function COption_u64Z_none(): number {
8058 if(!isWasmInitialized) {
8059 throw new Error("initializeWasm() must be awaited first!");
8061 const nativeResponseValue = wasm.TS_COption_u64Z_none();
8062 return nativeResponseValue;
8064 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
8066 export function COption_u64Z_free(_res: number): void {
8067 if(!isWasmInitialized) {
8068 throw new Error("initializeWasm() must be awaited first!");
8070 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
8071 // debug statements here
8073 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
8075 export function COption_u64Z_clone_ptr(arg: number): number {
8076 if(!isWasmInitialized) {
8077 throw new Error("initializeWasm() must be awaited first!");
8079 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
8080 return nativeResponseValue;
8082 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
8084 export function COption_u64Z_clone(orig: number): number {
8085 if(!isWasmInitialized) {
8086 throw new Error("initializeWasm() must be awaited first!");
8088 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
8089 return nativeResponseValue;
8091 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8093 export function CVec_u64Z_free(_res: number): void {
8094 if(!isWasmInitialized) {
8095 throw new Error("initializeWasm() must be awaited first!");
8097 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8098 // debug statements here
8100 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
8102 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
8103 if(!isWasmInitialized) {
8104 throw new Error("initializeWasm() must be awaited first!");
8106 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
8107 return nativeResponseValue;
8109 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
8111 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
8112 if(!isWasmInitialized) {
8113 throw new Error("initializeWasm() must be awaited first!");
8115 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
8116 return nativeResponseValue;
8118 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
8120 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
8121 if(!isWasmInitialized) {
8122 throw new Error("initializeWasm() must be awaited first!");
8124 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
8125 return nativeResponseValue;
8127 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
8129 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
8130 if(!isWasmInitialized) {
8131 throw new Error("initializeWasm() must be awaited first!");
8133 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
8134 // debug statements here
8136 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
8138 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
8139 if(!isWasmInitialized) {
8140 throw new Error("initializeWasm() must be awaited first!");
8142 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
8143 return nativeResponseValue;
8145 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
8147 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
8148 if(!isWasmInitialized) {
8149 throw new Error("initializeWasm() must be awaited first!");
8151 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
8152 return nativeResponseValue;
8154 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
8156 export function CVec_RouteHintHopZ_free(_res: number): void {
8157 if(!isWasmInitialized) {
8158 throw new Error("initializeWasm() must be awaited first!");
8160 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
8161 // debug statements here
8163 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
8165 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
8166 if(!isWasmInitialized) {
8167 throw new Error("initializeWasm() must be awaited first!");
8169 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
8170 return nativeResponseValue;
8172 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
8174 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
8175 if(!isWasmInitialized) {
8176 throw new Error("initializeWasm() must be awaited first!");
8178 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
8179 return nativeResponseValue;
8181 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
8183 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
8184 if(!isWasmInitialized) {
8185 throw new Error("initializeWasm() must be awaited first!");
8187 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
8188 return nativeResponseValue;
8190 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
8192 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
8193 if(!isWasmInitialized) {
8194 throw new Error("initializeWasm() must be awaited first!");
8196 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
8197 // debug statements here
8199 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
8201 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
8202 if(!isWasmInitialized) {
8203 throw new Error("initializeWasm() must be awaited first!");
8205 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
8206 return nativeResponseValue;
8208 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
8210 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
8211 if(!isWasmInitialized) {
8212 throw new Error("initializeWasm() must be awaited first!");
8214 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
8215 return nativeResponseValue;
8217 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
8219 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
8220 if(!isWasmInitialized) {
8221 throw new Error("initializeWasm() must be awaited first!");
8223 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
8224 return nativeResponseValue;
8226 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
8228 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
8229 if(!isWasmInitialized) {
8230 throw new Error("initializeWasm() must be awaited first!");
8232 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
8233 return nativeResponseValue;
8235 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
8237 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
8238 if(!isWasmInitialized) {
8239 throw new Error("initializeWasm() must be awaited first!");
8241 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
8242 return nativeResponseValue;
8244 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
8246 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
8247 if(!isWasmInitialized) {
8248 throw new Error("initializeWasm() must be awaited first!");
8250 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
8251 // debug statements here
8253 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
8255 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
8256 if(!isWasmInitialized) {
8257 throw new Error("initializeWasm() must be awaited first!");
8259 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
8260 return nativeResponseValue;
8262 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
8264 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
8265 if(!isWasmInitialized) {
8266 throw new Error("initializeWasm() must be awaited first!");
8268 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
8269 return nativeResponseValue;
8271 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8273 export function CVec_ChannelDetailsZ_free(_res: number): void {
8274 if(!isWasmInitialized) {
8275 throw new Error("initializeWasm() must be awaited first!");
8277 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8278 // debug statements here
8280 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8282 export function CResult_RouteLightningErrorZ_ok(o: number): number {
8283 if(!isWasmInitialized) {
8284 throw new Error("initializeWasm() must be awaited first!");
8286 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8287 return nativeResponseValue;
8289 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8291 export function CResult_RouteLightningErrorZ_err(e: number): number {
8292 if(!isWasmInitialized) {
8293 throw new Error("initializeWasm() must be awaited first!");
8295 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8296 return nativeResponseValue;
8298 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8300 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
8301 if(!isWasmInitialized) {
8302 throw new Error("initializeWasm() must be awaited first!");
8304 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8305 return nativeResponseValue;
8307 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8309 export function CResult_RouteLightningErrorZ_free(_res: number): void {
8310 if(!isWasmInitialized) {
8311 throw new Error("initializeWasm() must be awaited first!");
8313 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8314 // debug statements here
8316 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8318 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
8319 if(!isWasmInitialized) {
8320 throw new Error("initializeWasm() must be awaited first!");
8322 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8323 return nativeResponseValue;
8325 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8327 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
8328 if(!isWasmInitialized) {
8329 throw new Error("initializeWasm() must be awaited first!");
8331 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8332 return nativeResponseValue;
8334 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8336 export function CVec_PublicKeyZ_free(_res: number): void {
8337 if(!isWasmInitialized) {
8338 throw new Error("initializeWasm() must be awaited first!");
8340 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8341 // debug statements here
8343 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8345 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: number): number {
8346 if(!isWasmInitialized) {
8347 throw new Error("initializeWasm() must be awaited first!");
8349 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8350 return nativeResponseValue;
8352 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8354 export function CResult_PaymentPurposeDecodeErrorZ_err(e: number): number {
8355 if(!isWasmInitialized) {
8356 throw new Error("initializeWasm() must be awaited first!");
8358 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8359 return nativeResponseValue;
8361 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8363 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: number): boolean {
8364 if(!isWasmInitialized) {
8365 throw new Error("initializeWasm() must be awaited first!");
8367 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8368 return nativeResponseValue;
8370 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8372 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: number): void {
8373 if(!isWasmInitialized) {
8374 throw new Error("initializeWasm() must be awaited first!");
8376 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8377 // debug statements here
8379 // uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8381 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: number): number {
8382 if(!isWasmInitialized) {
8383 throw new Error("initializeWasm() must be awaited first!");
8385 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8386 return nativeResponseValue;
8388 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8390 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: number): number {
8391 if(!isWasmInitialized) {
8392 throw new Error("initializeWasm() must be awaited first!");
8394 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8395 return nativeResponseValue;
8397 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8399 export function COption_ClosureReasonZ_some(o: number): number {
8400 if(!isWasmInitialized) {
8401 throw new Error("initializeWasm() must be awaited first!");
8403 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8404 return nativeResponseValue;
8406 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8408 export function COption_ClosureReasonZ_none(): number {
8409 if(!isWasmInitialized) {
8410 throw new Error("initializeWasm() must be awaited first!");
8412 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8413 return nativeResponseValue;
8415 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8417 export function COption_ClosureReasonZ_free(_res: number): void {
8418 if(!isWasmInitialized) {
8419 throw new Error("initializeWasm() must be awaited first!");
8421 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8422 // debug statements here
8424 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8426 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8427 if(!isWasmInitialized) {
8428 throw new Error("initializeWasm() must be awaited first!");
8430 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8431 return nativeResponseValue;
8433 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8435 export function COption_ClosureReasonZ_clone(orig: number): number {
8436 if(!isWasmInitialized) {
8437 throw new Error("initializeWasm() must be awaited first!");
8439 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8440 return nativeResponseValue;
8442 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8444 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8445 if(!isWasmInitialized) {
8446 throw new Error("initializeWasm() must be awaited first!");
8448 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8449 return nativeResponseValue;
8451 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8453 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8454 if(!isWasmInitialized) {
8455 throw new Error("initializeWasm() must be awaited first!");
8457 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8458 return nativeResponseValue;
8460 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8462 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8463 if(!isWasmInitialized) {
8464 throw new Error("initializeWasm() must be awaited first!");
8466 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8467 return nativeResponseValue;
8469 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8471 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8472 if(!isWasmInitialized) {
8473 throw new Error("initializeWasm() must be awaited first!");
8475 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8476 // debug statements here
8478 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8480 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8481 if(!isWasmInitialized) {
8482 throw new Error("initializeWasm() must be awaited first!");
8484 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8485 return nativeResponseValue;
8487 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8489 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8490 if(!isWasmInitialized) {
8491 throw new Error("initializeWasm() must be awaited first!");
8493 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8494 return nativeResponseValue;
8496 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
8498 export function COption_HTLCDestinationZ_some(o: number): number {
8499 if(!isWasmInitialized) {
8500 throw new Error("initializeWasm() must be awaited first!");
8502 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
8503 return nativeResponseValue;
8505 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
8507 export function COption_HTLCDestinationZ_none(): number {
8508 if(!isWasmInitialized) {
8509 throw new Error("initializeWasm() must be awaited first!");
8511 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
8512 return nativeResponseValue;
8514 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
8516 export function COption_HTLCDestinationZ_free(_res: number): void {
8517 if(!isWasmInitialized) {
8518 throw new Error("initializeWasm() must be awaited first!");
8520 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
8521 // debug statements here
8523 // uintptr_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
8525 export function COption_HTLCDestinationZ_clone_ptr(arg: number): number {
8526 if(!isWasmInitialized) {
8527 throw new Error("initializeWasm() must be awaited first!");
8529 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
8530 return nativeResponseValue;
8532 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
8534 export function COption_HTLCDestinationZ_clone(orig: number): number {
8535 if(!isWasmInitialized) {
8536 throw new Error("initializeWasm() must be awaited first!");
8538 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
8539 return nativeResponseValue;
8541 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
8543 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: number): number {
8544 if(!isWasmInitialized) {
8545 throw new Error("initializeWasm() must be awaited first!");
8547 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
8548 return nativeResponseValue;
8550 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
8552 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: number): number {
8553 if(!isWasmInitialized) {
8554 throw new Error("initializeWasm() must be awaited first!");
8556 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
8557 return nativeResponseValue;
8559 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
8561 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: number): boolean {
8562 if(!isWasmInitialized) {
8563 throw new Error("initializeWasm() must be awaited first!");
8565 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
8566 return nativeResponseValue;
8568 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
8570 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: number): void {
8571 if(!isWasmInitialized) {
8572 throw new Error("initializeWasm() must be awaited first!");
8574 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
8575 // debug statements here
8577 // uintptr_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
8579 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: number): number {
8580 if(!isWasmInitialized) {
8581 throw new Error("initializeWasm() must be awaited first!");
8583 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
8584 return nativeResponseValue;
8586 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
8588 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: number): number {
8589 if(!isWasmInitialized) {
8590 throw new Error("initializeWasm() must be awaited first!");
8592 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
8593 return nativeResponseValue;
8595 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8597 export function COption_NetworkUpdateZ_some(o: number): number {
8598 if(!isWasmInitialized) {
8599 throw new Error("initializeWasm() must be awaited first!");
8601 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8602 return nativeResponseValue;
8604 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8606 export function COption_NetworkUpdateZ_none(): number {
8607 if(!isWasmInitialized) {
8608 throw new Error("initializeWasm() must be awaited first!");
8610 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8611 return nativeResponseValue;
8613 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8615 export function COption_NetworkUpdateZ_free(_res: number): void {
8616 if(!isWasmInitialized) {
8617 throw new Error("initializeWasm() must be awaited first!");
8619 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8620 // debug statements here
8622 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8624 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8625 if(!isWasmInitialized) {
8626 throw new Error("initializeWasm() must be awaited first!");
8628 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8629 return nativeResponseValue;
8631 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8633 export function COption_NetworkUpdateZ_clone(orig: number): number {
8634 if(!isWasmInitialized) {
8635 throw new Error("initializeWasm() must be awaited first!");
8637 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8638 return nativeResponseValue;
8640 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8642 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8643 if(!isWasmInitialized) {
8644 throw new Error("initializeWasm() must be awaited first!");
8646 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8647 // debug statements here
8649 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8651 export function COption_EventZ_some(o: number): number {
8652 if(!isWasmInitialized) {
8653 throw new Error("initializeWasm() must be awaited first!");
8655 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8656 return nativeResponseValue;
8658 // struct LDKCOption_EventZ COption_EventZ_none(void);
8660 export function COption_EventZ_none(): number {
8661 if(!isWasmInitialized) {
8662 throw new Error("initializeWasm() must be awaited first!");
8664 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8665 return nativeResponseValue;
8667 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8669 export function COption_EventZ_free(_res: number): void {
8670 if(!isWasmInitialized) {
8671 throw new Error("initializeWasm() must be awaited first!");
8673 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8674 // debug statements here
8676 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8678 export function COption_EventZ_clone_ptr(arg: number): number {
8679 if(!isWasmInitialized) {
8680 throw new Error("initializeWasm() must be awaited first!");
8682 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8683 return nativeResponseValue;
8685 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8687 export function COption_EventZ_clone(orig: number): number {
8688 if(!isWasmInitialized) {
8689 throw new Error("initializeWasm() must be awaited first!");
8691 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8692 return nativeResponseValue;
8694 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8696 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8697 if(!isWasmInitialized) {
8698 throw new Error("initializeWasm() must be awaited first!");
8700 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8701 return nativeResponseValue;
8703 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8705 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8706 if(!isWasmInitialized) {
8707 throw new Error("initializeWasm() must be awaited first!");
8709 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8710 return nativeResponseValue;
8712 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8714 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8715 if(!isWasmInitialized) {
8716 throw new Error("initializeWasm() must be awaited first!");
8718 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8719 return nativeResponseValue;
8721 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8723 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8724 if(!isWasmInitialized) {
8725 throw new Error("initializeWasm() must be awaited first!");
8727 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8728 // debug statements here
8730 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8732 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8733 if(!isWasmInitialized) {
8734 throw new Error("initializeWasm() must be awaited first!");
8736 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8737 return nativeResponseValue;
8739 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8741 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8742 if(!isWasmInitialized) {
8743 throw new Error("initializeWasm() must be awaited first!");
8745 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8746 return nativeResponseValue;
8748 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8750 export function CVec_MessageSendEventZ_free(_res: number): void {
8751 if(!isWasmInitialized) {
8752 throw new Error("initializeWasm() must be awaited first!");
8754 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8755 // debug statements here
8757 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8759 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
8760 if(!isWasmInitialized) {
8761 throw new Error("initializeWasm() must be awaited first!");
8763 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8764 return nativeResponseValue;
8766 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8768 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
8769 if(!isWasmInitialized) {
8770 throw new Error("initializeWasm() must be awaited first!");
8772 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8773 return nativeResponseValue;
8775 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8777 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
8778 if(!isWasmInitialized) {
8779 throw new Error("initializeWasm() must be awaited first!");
8781 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8782 return nativeResponseValue;
8784 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8786 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
8787 if(!isWasmInitialized) {
8788 throw new Error("initializeWasm() must be awaited first!");
8790 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8791 // debug statements here
8793 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8795 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
8796 if(!isWasmInitialized) {
8797 throw new Error("initializeWasm() must be awaited first!");
8799 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8800 return nativeResponseValue;
8802 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8804 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
8805 if(!isWasmInitialized) {
8806 throw new Error("initializeWasm() must be awaited first!");
8808 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8809 return nativeResponseValue;
8811 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8813 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
8814 if(!isWasmInitialized) {
8815 throw new Error("initializeWasm() must be awaited first!");
8817 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8818 return nativeResponseValue;
8820 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8822 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
8823 if(!isWasmInitialized) {
8824 throw new Error("initializeWasm() must be awaited first!");
8826 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8827 return nativeResponseValue;
8829 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8831 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
8832 if(!isWasmInitialized) {
8833 throw new Error("initializeWasm() must be awaited first!");
8835 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8836 return nativeResponseValue;
8838 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8840 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
8841 if(!isWasmInitialized) {
8842 throw new Error("initializeWasm() must be awaited first!");
8844 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8845 // debug statements here
8847 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8849 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8850 if(!isWasmInitialized) {
8851 throw new Error("initializeWasm() must be awaited first!");
8853 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8854 // debug statements here
8856 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8858 export function CVec_TxidZ_free(_res: number): void {
8859 if(!isWasmInitialized) {
8860 throw new Error("initializeWasm() must be awaited first!");
8862 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8863 // debug statements here
8865 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8867 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
8868 if(!isWasmInitialized) {
8869 throw new Error("initializeWasm() must be awaited first!");
8871 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8872 return nativeResponseValue;
8874 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8876 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
8877 if(!isWasmInitialized) {
8878 throw new Error("initializeWasm() must be awaited first!");
8880 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8881 return nativeResponseValue;
8883 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8885 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
8886 if(!isWasmInitialized) {
8887 throw new Error("initializeWasm() must be awaited first!");
8889 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8890 return nativeResponseValue;
8892 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8894 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
8895 if(!isWasmInitialized) {
8896 throw new Error("initializeWasm() must be awaited first!");
8898 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8899 // debug statements here
8901 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8903 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
8904 if(!isWasmInitialized) {
8905 throw new Error("initializeWasm() must be awaited first!");
8907 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8908 return nativeResponseValue;
8910 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8912 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
8913 if(!isWasmInitialized) {
8914 throw new Error("initializeWasm() must be awaited first!");
8916 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8917 return nativeResponseValue;
8919 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8921 export function CVec_MonitorEventZ_free(_res: number): void {
8922 if(!isWasmInitialized) {
8923 throw new Error("initializeWasm() must be awaited first!");
8925 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8926 // debug statements here
8928 // uintptr_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
8930 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: number): number {
8931 if(!isWasmInitialized) {
8932 throw new Error("initializeWasm() must be awaited first!");
8934 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
8935 return nativeResponseValue;
8937 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
8939 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: number): number {
8940 if(!isWasmInitialized) {
8941 throw new Error("initializeWasm() must be awaited first!");
8943 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
8944 return nativeResponseValue;
8946 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
8948 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: number, b: number, c: number): number {
8949 if(!isWasmInitialized) {
8950 throw new Error("initializeWasm() must be awaited first!");
8952 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
8953 return nativeResponseValue;
8955 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
8957 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: number): void {
8958 if(!isWasmInitialized) {
8959 throw new Error("initializeWasm() must be awaited first!");
8961 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
8962 // debug statements here
8964 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
8966 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
8967 if(!isWasmInitialized) {
8968 throw new Error("initializeWasm() must be awaited first!");
8970 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
8971 // debug statements here
8973 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8975 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8976 if(!isWasmInitialized) {
8977 throw new Error("initializeWasm() must be awaited first!");
8979 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8980 return nativeResponseValue;
8982 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8984 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8985 if(!isWasmInitialized) {
8986 throw new Error("initializeWasm() must be awaited first!");
8988 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8989 return nativeResponseValue;
8991 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8993 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8994 if(!isWasmInitialized) {
8995 throw new Error("initializeWasm() must be awaited first!");
8997 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8998 // debug statements here
9000 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
9002 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
9003 if(!isWasmInitialized) {
9004 throw new Error("initializeWasm() must be awaited first!");
9006 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
9007 return nativeResponseValue;
9009 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
9011 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
9012 if(!isWasmInitialized) {
9013 throw new Error("initializeWasm() must be awaited first!");
9015 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
9016 return nativeResponseValue;
9018 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
9020 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
9021 if(!isWasmInitialized) {
9022 throw new Error("initializeWasm() must be awaited first!");
9024 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
9025 return nativeResponseValue;
9027 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
9029 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
9030 if(!isWasmInitialized) {
9031 throw new Error("initializeWasm() must be awaited first!");
9033 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
9034 return nativeResponseValue;
9036 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
9038 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
9039 if(!isWasmInitialized) {
9040 throw new Error("initializeWasm() must be awaited first!");
9042 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
9043 return nativeResponseValue;
9045 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
9047 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
9048 if(!isWasmInitialized) {
9049 throw new Error("initializeWasm() must be awaited first!");
9051 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
9052 // debug statements here
9054 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
9056 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
9057 if(!isWasmInitialized) {
9058 throw new Error("initializeWasm() must be awaited first!");
9060 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
9061 return nativeResponseValue;
9063 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
9065 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
9066 if(!isWasmInitialized) {
9067 throw new Error("initializeWasm() must be awaited first!");
9069 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
9070 return nativeResponseValue;
9072 // uintptr_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
9074 export function C2Tuple_u64u64Z_clone_ptr(arg: number): number {
9075 if(!isWasmInitialized) {
9076 throw new Error("initializeWasm() must be awaited first!");
9078 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
9079 return nativeResponseValue;
9081 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
9083 export function C2Tuple_u64u64Z_clone(orig: number): number {
9084 if(!isWasmInitialized) {
9085 throw new Error("initializeWasm() must be awaited first!");
9087 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
9088 return nativeResponseValue;
9090 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
9092 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): number {
9093 if(!isWasmInitialized) {
9094 throw new Error("initializeWasm() must be awaited first!");
9096 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
9097 return nativeResponseValue;
9099 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
9101 export function C2Tuple_u64u64Z_free(_res: number): void {
9102 if(!isWasmInitialized) {
9103 throw new Error("initializeWasm() must be awaited first!");
9105 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
9106 // debug statements here
9108 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
9110 export function COption_C2Tuple_u64u64ZZ_some(o: number): number {
9111 if(!isWasmInitialized) {
9112 throw new Error("initializeWasm() must be awaited first!");
9114 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
9115 return nativeResponseValue;
9117 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
9119 export function COption_C2Tuple_u64u64ZZ_none(): number {
9120 if(!isWasmInitialized) {
9121 throw new Error("initializeWasm() must be awaited first!");
9123 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
9124 return nativeResponseValue;
9126 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
9128 export function COption_C2Tuple_u64u64ZZ_free(_res: number): void {
9129 if(!isWasmInitialized) {
9130 throw new Error("initializeWasm() must be awaited first!");
9132 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
9133 // debug statements here
9135 // uintptr_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
9137 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: number): number {
9138 if(!isWasmInitialized) {
9139 throw new Error("initializeWasm() must be awaited first!");
9141 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
9142 return nativeResponseValue;
9144 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
9146 export function COption_C2Tuple_u64u64ZZ_clone(orig: number): number {
9147 if(!isWasmInitialized) {
9148 throw new Error("initializeWasm() must be awaited first!");
9150 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
9151 return nativeResponseValue;
9153 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
9155 export function CVec_NodeIdZ_free(_res: number): void {
9156 if(!isWasmInitialized) {
9157 throw new Error("initializeWasm() must be awaited first!");
9159 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
9160 // debug statements here
9162 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
9164 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
9165 if(!isWasmInitialized) {
9166 throw new Error("initializeWasm() must be awaited first!");
9168 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
9169 return nativeResponseValue;
9171 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
9173 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
9174 if(!isWasmInitialized) {
9175 throw new Error("initializeWasm() must be awaited first!");
9177 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
9178 return nativeResponseValue;
9180 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
9182 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
9183 if(!isWasmInitialized) {
9184 throw new Error("initializeWasm() must be awaited first!");
9186 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
9187 return nativeResponseValue;
9189 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
9191 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
9192 if(!isWasmInitialized) {
9193 throw new Error("initializeWasm() must be awaited first!");
9195 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
9196 // debug statements here
9198 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
9200 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
9201 if(!isWasmInitialized) {
9202 throw new Error("initializeWasm() must be awaited first!");
9204 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
9205 return nativeResponseValue;
9207 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9209 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
9210 if(!isWasmInitialized) {
9211 throw new Error("initializeWasm() must be awaited first!");
9213 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
9214 return nativeResponseValue;
9216 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
9218 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9219 if(!isWasmInitialized) {
9220 throw new Error("initializeWasm() must be awaited first!");
9222 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
9223 return nativeResponseValue;
9225 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
9227 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
9228 if(!isWasmInitialized) {
9229 throw new Error("initializeWasm() must be awaited first!");
9231 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
9232 // debug statements here
9234 // uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
9236 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9237 if(!isWasmInitialized) {
9238 throw new Error("initializeWasm() must be awaited first!");
9240 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
9241 return nativeResponseValue;
9243 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
9245 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: number): number {
9246 if(!isWasmInitialized) {
9247 throw new Error("initializeWasm() must be awaited first!");
9249 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
9250 return nativeResponseValue;
9252 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
9254 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
9255 if(!isWasmInitialized) {
9256 throw new Error("initializeWasm() must be awaited first!");
9258 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
9259 return nativeResponseValue;
9261 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9263 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
9264 if(!isWasmInitialized) {
9265 throw new Error("initializeWasm() must be awaited first!");
9267 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
9268 return nativeResponseValue;
9270 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
9272 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9273 if(!isWasmInitialized) {
9274 throw new Error("initializeWasm() must be awaited first!");
9276 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
9277 return nativeResponseValue;
9279 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
9281 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
9282 if(!isWasmInitialized) {
9283 throw new Error("initializeWasm() must be awaited first!");
9285 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
9286 // debug statements here
9288 // uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
9290 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9291 if(!isWasmInitialized) {
9292 throw new Error("initializeWasm() must be awaited first!");
9294 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
9295 return nativeResponseValue;
9297 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
9299 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: number): number {
9300 if(!isWasmInitialized) {
9301 throw new Error("initializeWasm() must be awaited first!");
9303 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
9304 return nativeResponseValue;
9306 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
9308 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
9309 if(!isWasmInitialized) {
9310 throw new Error("initializeWasm() must be awaited first!");
9312 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
9313 return nativeResponseValue;
9315 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9317 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
9318 if(!isWasmInitialized) {
9319 throw new Error("initializeWasm() must be awaited first!");
9321 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
9322 return nativeResponseValue;
9324 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
9326 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9327 if(!isWasmInitialized) {
9328 throw new Error("initializeWasm() must be awaited first!");
9330 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
9331 return nativeResponseValue;
9333 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
9335 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
9336 if(!isWasmInitialized) {
9337 throw new Error("initializeWasm() must be awaited first!");
9339 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
9340 // debug statements here
9342 // uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9344 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9345 if(!isWasmInitialized) {
9346 throw new Error("initializeWasm() must be awaited first!");
9348 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
9349 return nativeResponseValue;
9351 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9353 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: number): number {
9354 if(!isWasmInitialized) {
9355 throw new Error("initializeWasm() must be awaited first!");
9357 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
9358 return nativeResponseValue;
9360 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
9362 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
9363 if(!isWasmInitialized) {
9364 throw new Error("initializeWasm() must be awaited first!");
9366 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
9367 return nativeResponseValue;
9369 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9371 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
9372 if(!isWasmInitialized) {
9373 throw new Error("initializeWasm() must be awaited first!");
9375 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
9376 return nativeResponseValue;
9378 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
9380 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9381 if(!isWasmInitialized) {
9382 throw new Error("initializeWasm() must be awaited first!");
9384 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
9385 return nativeResponseValue;
9387 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
9389 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
9390 if(!isWasmInitialized) {
9391 throw new Error("initializeWasm() must be awaited first!");
9393 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
9394 // debug statements here
9396 // uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
9398 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9399 if(!isWasmInitialized) {
9400 throw new Error("initializeWasm() must be awaited first!");
9402 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
9403 return nativeResponseValue;
9405 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
9407 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: number): number {
9408 if(!isWasmInitialized) {
9409 throw new Error("initializeWasm() must be awaited first!");
9411 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
9412 return nativeResponseValue;
9414 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
9416 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
9417 if(!isWasmInitialized) {
9418 throw new Error("initializeWasm() must be awaited first!");
9420 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
9421 return nativeResponseValue;
9423 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9425 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
9426 if(!isWasmInitialized) {
9427 throw new Error("initializeWasm() must be awaited first!");
9429 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
9430 return nativeResponseValue;
9432 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
9434 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9435 if(!isWasmInitialized) {
9436 throw new Error("initializeWasm() must be awaited first!");
9438 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9439 return nativeResponseValue;
9441 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9443 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
9444 if(!isWasmInitialized) {
9445 throw new Error("initializeWasm() must be awaited first!");
9447 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9448 // debug statements here
9450 // uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9452 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9453 if(!isWasmInitialized) {
9454 throw new Error("initializeWasm() must be awaited first!");
9456 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
9457 return nativeResponseValue;
9459 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9461 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: number): number {
9462 if(!isWasmInitialized) {
9463 throw new Error("initializeWasm() must be awaited first!");
9465 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
9466 return nativeResponseValue;
9468 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
9470 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
9471 if(!isWasmInitialized) {
9472 throw new Error("initializeWasm() must be awaited first!");
9474 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
9475 return nativeResponseValue;
9477 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
9479 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
9480 if(!isWasmInitialized) {
9481 throw new Error("initializeWasm() must be awaited first!");
9483 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
9484 return nativeResponseValue;
9486 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
9488 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
9489 if(!isWasmInitialized) {
9490 throw new Error("initializeWasm() must be awaited first!");
9492 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
9493 return nativeResponseValue;
9495 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
9497 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
9498 if(!isWasmInitialized) {
9499 throw new Error("initializeWasm() must be awaited first!");
9501 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
9502 // debug statements here
9504 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
9506 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
9507 if(!isWasmInitialized) {
9508 throw new Error("initializeWasm() must be awaited first!");
9510 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
9511 return nativeResponseValue;
9513 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9515 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
9516 if(!isWasmInitialized) {
9517 throw new Error("initializeWasm() must be awaited first!");
9519 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9520 return nativeResponseValue;
9522 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9524 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
9525 if(!isWasmInitialized) {
9526 throw new Error("initializeWasm() must be awaited first!");
9528 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9529 return nativeResponseValue;
9531 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9533 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
9534 if(!isWasmInitialized) {
9535 throw new Error("initializeWasm() must be awaited first!");
9537 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9538 return nativeResponseValue;
9540 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9542 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
9543 if(!isWasmInitialized) {
9544 throw new Error("initializeWasm() must be awaited first!");
9546 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9547 return nativeResponseValue;
9549 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9551 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
9552 if(!isWasmInitialized) {
9553 throw new Error("initializeWasm() must be awaited first!");
9555 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9556 // debug statements here
9558 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9560 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
9561 if(!isWasmInitialized) {
9562 throw new Error("initializeWasm() must be awaited first!");
9564 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9565 return nativeResponseValue;
9567 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9569 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
9570 if(!isWasmInitialized) {
9571 throw new Error("initializeWasm() must be awaited first!");
9573 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9574 return nativeResponseValue;
9576 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9578 export function COption_AccessZ_some(o: number): number {
9579 if(!isWasmInitialized) {
9580 throw new Error("initializeWasm() must be awaited first!");
9582 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9583 return nativeResponseValue;
9585 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9587 export function COption_AccessZ_none(): number {
9588 if(!isWasmInitialized) {
9589 throw new Error("initializeWasm() must be awaited first!");
9591 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9592 return nativeResponseValue;
9594 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9596 export function COption_AccessZ_free(_res: number): void {
9597 if(!isWasmInitialized) {
9598 throw new Error("initializeWasm() must be awaited first!");
9600 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9601 // debug statements here
9603 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9605 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
9606 if(!isWasmInitialized) {
9607 throw new Error("initializeWasm() must be awaited first!");
9609 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9610 return nativeResponseValue;
9612 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9614 export function CResult_boolLightningErrorZ_err(e: number): number {
9615 if(!isWasmInitialized) {
9616 throw new Error("initializeWasm() must be awaited first!");
9618 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9619 return nativeResponseValue;
9621 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9623 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
9624 if(!isWasmInitialized) {
9625 throw new Error("initializeWasm() must be awaited first!");
9627 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9628 return nativeResponseValue;
9630 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9632 export function CResult_boolLightningErrorZ_free(_res: number): void {
9633 if(!isWasmInitialized) {
9634 throw new Error("initializeWasm() must be awaited first!");
9636 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9637 // debug statements here
9639 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9641 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
9642 if(!isWasmInitialized) {
9643 throw new Error("initializeWasm() must be awaited first!");
9645 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9646 return nativeResponseValue;
9648 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9650 export function CResult_boolLightningErrorZ_clone(orig: number): number {
9651 if(!isWasmInitialized) {
9652 throw new Error("initializeWasm() must be awaited first!");
9654 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9655 return nativeResponseValue;
9657 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9659 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
9660 if(!isWasmInitialized) {
9661 throw new Error("initializeWasm() must be awaited first!");
9663 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9664 return nativeResponseValue;
9666 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9668 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
9669 if(!isWasmInitialized) {
9670 throw new Error("initializeWasm() must be awaited first!");
9672 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9673 return nativeResponseValue;
9675 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9677 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
9678 if(!isWasmInitialized) {
9679 throw new Error("initializeWasm() must be awaited first!");
9681 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9682 return nativeResponseValue;
9684 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9686 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
9687 if(!isWasmInitialized) {
9688 throw new Error("initializeWasm() must be awaited first!");
9690 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9691 // debug statements here
9693 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9695 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9696 if(!isWasmInitialized) {
9697 throw new Error("initializeWasm() must be awaited first!");
9699 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9700 // debug statements here
9702 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9704 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9705 if(!isWasmInitialized) {
9706 throw new Error("initializeWasm() must be awaited first!");
9708 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9709 // debug statements here
9711 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9713 export function CResult_NoneLightningErrorZ_ok(): number {
9714 if(!isWasmInitialized) {
9715 throw new Error("initializeWasm() must be awaited first!");
9717 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9718 return nativeResponseValue;
9720 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9722 export function CResult_NoneLightningErrorZ_err(e: number): number {
9723 if(!isWasmInitialized) {
9724 throw new Error("initializeWasm() must be awaited first!");
9726 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9727 return nativeResponseValue;
9729 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9731 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
9732 if(!isWasmInitialized) {
9733 throw new Error("initializeWasm() must be awaited first!");
9735 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9736 return nativeResponseValue;
9738 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9740 export function CResult_NoneLightningErrorZ_free(_res: number): void {
9741 if(!isWasmInitialized) {
9742 throw new Error("initializeWasm() must be awaited first!");
9744 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9745 // debug statements here
9747 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9749 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
9750 if(!isWasmInitialized) {
9751 throw new Error("initializeWasm() must be awaited first!");
9753 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9754 return nativeResponseValue;
9756 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9758 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
9759 if(!isWasmInitialized) {
9760 throw new Error("initializeWasm() must be awaited first!");
9762 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9763 return nativeResponseValue;
9765 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9767 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
9768 if(!isWasmInitialized) {
9769 throw new Error("initializeWasm() must be awaited first!");
9771 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9772 return nativeResponseValue;
9774 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9776 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
9777 if(!isWasmInitialized) {
9778 throw new Error("initializeWasm() must be awaited first!");
9780 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9781 return nativeResponseValue;
9783 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9785 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
9786 if(!isWasmInitialized) {
9787 throw new Error("initializeWasm() must be awaited first!");
9789 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9790 return nativeResponseValue;
9792 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9794 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
9795 if(!isWasmInitialized) {
9796 throw new Error("initializeWasm() must be awaited first!");
9798 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9799 // debug statements here
9801 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9803 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
9804 if(!isWasmInitialized) {
9805 throw new Error("initializeWasm() must be awaited first!");
9807 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9808 return nativeResponseValue;
9810 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9812 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
9813 if(!isWasmInitialized) {
9814 throw new Error("initializeWasm() must be awaited first!");
9816 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9817 return nativeResponseValue;
9819 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9821 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
9822 if(!isWasmInitialized) {
9823 throw new Error("initializeWasm() must be awaited first!");
9825 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9826 return nativeResponseValue;
9828 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9830 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
9831 if(!isWasmInitialized) {
9832 throw new Error("initializeWasm() must be awaited first!");
9834 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9835 return nativeResponseValue;
9837 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9839 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
9840 if(!isWasmInitialized) {
9841 throw new Error("initializeWasm() must be awaited first!");
9843 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9844 return nativeResponseValue;
9846 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9848 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
9849 if(!isWasmInitialized) {
9850 throw new Error("initializeWasm() must be awaited first!");
9852 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9853 // debug statements here
9855 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9857 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
9858 if(!isWasmInitialized) {
9859 throw new Error("initializeWasm() must be awaited first!");
9861 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9862 return nativeResponseValue;
9864 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9866 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
9867 if(!isWasmInitialized) {
9868 throw new Error("initializeWasm() must be awaited first!");
9870 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9871 return nativeResponseValue;
9873 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9875 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
9876 if(!isWasmInitialized) {
9877 throw new Error("initializeWasm() must be awaited first!");
9879 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9880 return nativeResponseValue;
9882 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9884 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
9885 if(!isWasmInitialized) {
9886 throw new Error("initializeWasm() must be awaited first!");
9888 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9889 return nativeResponseValue;
9891 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9893 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
9894 if(!isWasmInitialized) {
9895 throw new Error("initializeWasm() must be awaited first!");
9897 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9898 return nativeResponseValue;
9900 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9902 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
9903 if(!isWasmInitialized) {
9904 throw new Error("initializeWasm() must be awaited first!");
9906 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9907 // debug statements here
9909 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9911 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
9912 if(!isWasmInitialized) {
9913 throw new Error("initializeWasm() must be awaited first!");
9915 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9916 return nativeResponseValue;
9918 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9920 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
9921 if(!isWasmInitialized) {
9922 throw new Error("initializeWasm() must be awaited first!");
9924 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9925 return nativeResponseValue;
9927 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9929 export function CVec_NetAddressZ_free(_res: number): void {
9930 if(!isWasmInitialized) {
9931 throw new Error("initializeWasm() must be awaited first!");
9933 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9934 // debug statements here
9936 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9938 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
9939 if(!isWasmInitialized) {
9940 throw new Error("initializeWasm() must be awaited first!");
9942 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9943 return nativeResponseValue;
9945 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9947 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
9948 if(!isWasmInitialized) {
9949 throw new Error("initializeWasm() must be awaited first!");
9951 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9952 return nativeResponseValue;
9954 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9956 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
9957 if(!isWasmInitialized) {
9958 throw new Error("initializeWasm() must be awaited first!");
9960 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9961 return nativeResponseValue;
9963 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9965 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
9966 if(!isWasmInitialized) {
9967 throw new Error("initializeWasm() must be awaited first!");
9969 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9970 // debug statements here
9972 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9974 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
9975 if(!isWasmInitialized) {
9976 throw new Error("initializeWasm() must be awaited first!");
9978 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9979 return nativeResponseValue;
9981 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9983 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
9984 if(!isWasmInitialized) {
9985 throw new Error("initializeWasm() must be awaited first!");
9987 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9988 return nativeResponseValue;
9990 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
9992 export function CResult_NodeAliasDecodeErrorZ_ok(o: number): number {
9993 if(!isWasmInitialized) {
9994 throw new Error("initializeWasm() must be awaited first!");
9996 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
9997 return nativeResponseValue;
9999 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
10001 export function CResult_NodeAliasDecodeErrorZ_err(e: number): number {
10002 if(!isWasmInitialized) {
10003 throw new Error("initializeWasm() must be awaited first!");
10005 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
10006 return nativeResponseValue;
10008 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
10010 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: number): boolean {
10011 if(!isWasmInitialized) {
10012 throw new Error("initializeWasm() must be awaited first!");
10014 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
10015 return nativeResponseValue;
10017 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
10019 export function CResult_NodeAliasDecodeErrorZ_free(_res: number): void {
10020 if(!isWasmInitialized) {
10021 throw new Error("initializeWasm() must be awaited first!");
10023 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
10024 // debug statements here
10026 // uintptr_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
10028 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: number): number {
10029 if(!isWasmInitialized) {
10030 throw new Error("initializeWasm() must be awaited first!");
10032 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
10033 return nativeResponseValue;
10035 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
10037 export function CResult_NodeAliasDecodeErrorZ_clone(orig: number): number {
10038 if(!isWasmInitialized) {
10039 throw new Error("initializeWasm() must be awaited first!");
10041 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
10042 return nativeResponseValue;
10044 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
10046 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
10047 if(!isWasmInitialized) {
10048 throw new Error("initializeWasm() must be awaited first!");
10050 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
10051 return nativeResponseValue;
10053 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
10055 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
10056 if(!isWasmInitialized) {
10057 throw new Error("initializeWasm() must be awaited first!");
10059 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
10060 return nativeResponseValue;
10062 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
10064 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
10065 if(!isWasmInitialized) {
10066 throw new Error("initializeWasm() must be awaited first!");
10068 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
10069 return nativeResponseValue;
10071 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
10073 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
10074 if(!isWasmInitialized) {
10075 throw new Error("initializeWasm() must be awaited first!");
10077 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
10078 // debug statements here
10080 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
10082 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
10083 if(!isWasmInitialized) {
10084 throw new Error("initializeWasm() must be awaited first!");
10086 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
10087 return nativeResponseValue;
10089 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
10091 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
10092 if(!isWasmInitialized) {
10093 throw new Error("initializeWasm() must be awaited first!");
10095 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
10096 return nativeResponseValue;
10098 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
10100 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
10101 if(!isWasmInitialized) {
10102 throw new Error("initializeWasm() must be awaited first!");
10104 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
10105 return nativeResponseValue;
10107 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
10109 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
10110 if(!isWasmInitialized) {
10111 throw new Error("initializeWasm() must be awaited first!");
10113 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
10114 return nativeResponseValue;
10116 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
10118 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
10119 if(!isWasmInitialized) {
10120 throw new Error("initializeWasm() must be awaited first!");
10122 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
10123 return nativeResponseValue;
10125 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
10127 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
10128 if(!isWasmInitialized) {
10129 throw new Error("initializeWasm() must be awaited first!");
10131 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
10132 // debug statements here
10134 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
10136 export function COption_CVec_NetAddressZZ_some(o: number): number {
10137 if(!isWasmInitialized) {
10138 throw new Error("initializeWasm() must be awaited first!");
10140 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
10141 return nativeResponseValue;
10143 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
10145 export function COption_CVec_NetAddressZZ_none(): number {
10146 if(!isWasmInitialized) {
10147 throw new Error("initializeWasm() must be awaited first!");
10149 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
10150 return nativeResponseValue;
10152 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
10154 export function COption_CVec_NetAddressZZ_free(_res: number): void {
10155 if(!isWasmInitialized) {
10156 throw new Error("initializeWasm() must be awaited first!");
10158 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
10159 // debug statements here
10161 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
10163 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
10164 if(!isWasmInitialized) {
10165 throw new Error("initializeWasm() must be awaited first!");
10167 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
10168 return nativeResponseValue;
10170 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
10172 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
10173 if(!isWasmInitialized) {
10174 throw new Error("initializeWasm() must be awaited first!");
10176 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
10177 return nativeResponseValue;
10179 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10181 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10182 if(!isWasmInitialized) {
10183 throw new Error("initializeWasm() must be awaited first!");
10185 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10186 return nativeResponseValue;
10188 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10190 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10191 if(!isWasmInitialized) {
10192 throw new Error("initializeWasm() must be awaited first!");
10194 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10195 return nativeResponseValue;
10197 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10199 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10200 if(!isWasmInitialized) {
10201 throw new Error("initializeWasm() must be awaited first!");
10203 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10204 return nativeResponseValue;
10206 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10208 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10209 if(!isWasmInitialized) {
10210 throw new Error("initializeWasm() must be awaited first!");
10212 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10213 // debug statements here
10215 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10217 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10218 if(!isWasmInitialized) {
10219 throw new Error("initializeWasm() must be awaited first!");
10221 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10222 return nativeResponseValue;
10224 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10226 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10227 if(!isWasmInitialized) {
10228 throw new Error("initializeWasm() must be awaited first!");
10230 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10231 return nativeResponseValue;
10233 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10235 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10236 if(!isWasmInitialized) {
10237 throw new Error("initializeWasm() must be awaited first!");
10239 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10240 return nativeResponseValue;
10242 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10244 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10245 if(!isWasmInitialized) {
10246 throw new Error("initializeWasm() must be awaited first!");
10248 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
10249 return nativeResponseValue;
10251 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10253 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10254 if(!isWasmInitialized) {
10255 throw new Error("initializeWasm() must be awaited first!");
10257 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10258 return nativeResponseValue;
10260 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
10262 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10263 if(!isWasmInitialized) {
10264 throw new Error("initializeWasm() must be awaited first!");
10266 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
10267 // debug statements here
10269 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10271 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10272 if(!isWasmInitialized) {
10273 throw new Error("initializeWasm() must be awaited first!");
10275 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10276 return nativeResponseValue;
10278 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10280 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10281 if(!isWasmInitialized) {
10282 throw new Error("initializeWasm() must be awaited first!");
10284 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10285 return nativeResponseValue;
10287 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
10289 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
10290 if(!isWasmInitialized) {
10291 throw new Error("initializeWasm() must be awaited first!");
10293 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
10294 return nativeResponseValue;
10296 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10298 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
10299 if(!isWasmInitialized) {
10300 throw new Error("initializeWasm() must be awaited first!");
10302 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
10303 return nativeResponseValue;
10305 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10307 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10308 if(!isWasmInitialized) {
10309 throw new Error("initializeWasm() must be awaited first!");
10311 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
10312 return nativeResponseValue;
10314 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
10316 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
10317 if(!isWasmInitialized) {
10318 throw new Error("initializeWasm() must be awaited first!");
10320 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10321 // debug statements here
10323 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10325 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10326 if(!isWasmInitialized) {
10327 throw new Error("initializeWasm() must be awaited first!");
10329 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10330 return nativeResponseValue;
10332 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10334 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10335 if(!isWasmInitialized) {
10336 throw new Error("initializeWasm() must be awaited first!");
10338 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
10339 return nativeResponseValue;
10341 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
10343 export function CVec_PaymentPreimageZ_free(_res: number): void {
10344 if(!isWasmInitialized) {
10345 throw new Error("initializeWasm() must be awaited first!");
10347 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
10348 // debug statements here
10350 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10352 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
10353 if(!isWasmInitialized) {
10354 throw new Error("initializeWasm() must be awaited first!");
10356 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10357 return nativeResponseValue;
10359 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
10361 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
10362 if(!isWasmInitialized) {
10363 throw new Error("initializeWasm() must be awaited first!");
10365 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
10366 return nativeResponseValue;
10368 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
10370 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
10371 if(!isWasmInitialized) {
10372 throw new Error("initializeWasm() must be awaited first!");
10374 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
10375 return nativeResponseValue;
10377 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
10379 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
10380 if(!isWasmInitialized) {
10381 throw new Error("initializeWasm() must be awaited first!");
10383 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
10384 // debug statements here
10386 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
10388 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
10389 if(!isWasmInitialized) {
10390 throw new Error("initializeWasm() must be awaited first!");
10392 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
10393 return nativeResponseValue;
10395 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
10397 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
10398 if(!isWasmInitialized) {
10399 throw new Error("initializeWasm() must be awaited first!");
10401 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
10402 return nativeResponseValue;
10404 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
10406 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
10407 if(!isWasmInitialized) {
10408 throw new Error("initializeWasm() must be awaited first!");
10410 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
10411 return nativeResponseValue;
10413 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
10415 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
10416 if(!isWasmInitialized) {
10417 throw new Error("initializeWasm() must be awaited first!");
10419 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
10420 // debug statements here
10422 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
10424 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
10425 if(!isWasmInitialized) {
10426 throw new Error("initializeWasm() must be awaited first!");
10428 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
10429 return nativeResponseValue;
10431 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
10433 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
10434 if(!isWasmInitialized) {
10435 throw new Error("initializeWasm() must be awaited first!");
10437 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
10438 return nativeResponseValue;
10440 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
10442 export function CResult_SignatureNoneZ_ok(o: number): number {
10443 if(!isWasmInitialized) {
10444 throw new Error("initializeWasm() must be awaited first!");
10446 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
10447 return nativeResponseValue;
10449 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
10451 export function CResult_SignatureNoneZ_err(): number {
10452 if(!isWasmInitialized) {
10453 throw new Error("initializeWasm() must be awaited first!");
10455 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
10456 return nativeResponseValue;
10458 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
10460 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
10461 if(!isWasmInitialized) {
10462 throw new Error("initializeWasm() must be awaited first!");
10464 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
10465 return nativeResponseValue;
10467 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
10469 export function CResult_SignatureNoneZ_free(_res: number): void {
10470 if(!isWasmInitialized) {
10471 throw new Error("initializeWasm() must be awaited first!");
10473 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
10474 // debug statements here
10476 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
10478 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
10479 if(!isWasmInitialized) {
10480 throw new Error("initializeWasm() must be awaited first!");
10482 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
10483 return nativeResponseValue;
10485 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
10487 export function CResult_SignatureNoneZ_clone(orig: number): number {
10488 if(!isWasmInitialized) {
10489 throw new Error("initializeWasm() must be awaited first!");
10491 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
10492 return nativeResponseValue;
10494 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
10496 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
10497 if(!isWasmInitialized) {
10498 throw new Error("initializeWasm() must be awaited first!");
10500 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
10501 return nativeResponseValue;
10503 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
10505 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
10506 if(!isWasmInitialized) {
10507 throw new Error("initializeWasm() must be awaited first!");
10509 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
10510 return nativeResponseValue;
10512 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
10514 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
10515 if(!isWasmInitialized) {
10516 throw new Error("initializeWasm() must be awaited first!");
10518 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
10519 return nativeResponseValue;
10521 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
10523 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
10524 if(!isWasmInitialized) {
10525 throw new Error("initializeWasm() must be awaited first!");
10527 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
10528 // debug statements here
10530 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
10532 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
10533 if(!isWasmInitialized) {
10534 throw new Error("initializeWasm() must be awaited first!");
10536 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
10537 return nativeResponseValue;
10539 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
10541 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
10542 if(!isWasmInitialized) {
10543 throw new Error("initializeWasm() must be awaited first!");
10545 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
10546 return nativeResponseValue;
10548 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
10550 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
10551 if(!isWasmInitialized) {
10552 throw new Error("initializeWasm() must be awaited first!");
10554 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
10555 return nativeResponseValue;
10557 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10559 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
10560 if(!isWasmInitialized) {
10561 throw new Error("initializeWasm() must be awaited first!");
10563 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10564 // debug statements here
10566 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10568 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
10569 if(!isWasmInitialized) {
10570 throw new Error("initializeWasm() must be awaited first!");
10572 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10573 return nativeResponseValue;
10575 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10577 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
10578 if(!isWasmInitialized) {
10579 throw new Error("initializeWasm() must be awaited first!");
10581 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10582 return nativeResponseValue;
10584 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10586 export function CResult_SecretKeyNoneZ_ok(o: number): number {
10587 if(!isWasmInitialized) {
10588 throw new Error("initializeWasm() must be awaited first!");
10590 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10591 return nativeResponseValue;
10593 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10595 export function CResult_SecretKeyNoneZ_err(): number {
10596 if(!isWasmInitialized) {
10597 throw new Error("initializeWasm() must be awaited first!");
10599 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10600 return nativeResponseValue;
10602 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10604 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
10605 if(!isWasmInitialized) {
10606 throw new Error("initializeWasm() must be awaited first!");
10608 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10609 return nativeResponseValue;
10611 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10613 export function CResult_SecretKeyNoneZ_free(_res: number): void {
10614 if(!isWasmInitialized) {
10615 throw new Error("initializeWasm() must be awaited first!");
10617 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10618 // debug statements here
10620 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10622 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
10623 if(!isWasmInitialized) {
10624 throw new Error("initializeWasm() must be awaited first!");
10626 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10627 return nativeResponseValue;
10629 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10631 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
10632 if(!isWasmInitialized) {
10633 throw new Error("initializeWasm() must be awaited first!");
10635 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10636 return nativeResponseValue;
10638 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10640 export function CResult_SignDecodeErrorZ_ok(o: number): number {
10641 if(!isWasmInitialized) {
10642 throw new Error("initializeWasm() must be awaited first!");
10644 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10645 return nativeResponseValue;
10647 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10649 export function CResult_SignDecodeErrorZ_err(e: number): number {
10650 if(!isWasmInitialized) {
10651 throw new Error("initializeWasm() must be awaited first!");
10653 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10654 return nativeResponseValue;
10656 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10658 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
10659 if(!isWasmInitialized) {
10660 throw new Error("initializeWasm() must be awaited first!");
10662 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10663 return nativeResponseValue;
10665 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10667 export function CResult_SignDecodeErrorZ_free(_res: number): void {
10668 if(!isWasmInitialized) {
10669 throw new Error("initializeWasm() must be awaited first!");
10671 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10672 // debug statements here
10674 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10676 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
10677 if(!isWasmInitialized) {
10678 throw new Error("initializeWasm() must be awaited first!");
10680 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10681 return nativeResponseValue;
10683 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10685 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
10686 if(!isWasmInitialized) {
10687 throw new Error("initializeWasm() must be awaited first!");
10689 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10690 return nativeResponseValue;
10692 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10694 export function CVec_u5Z_free(_res: number): void {
10695 if(!isWasmInitialized) {
10696 throw new Error("initializeWasm() must be awaited first!");
10698 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10699 // debug statements here
10701 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10703 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
10704 if(!isWasmInitialized) {
10705 throw new Error("initializeWasm() must be awaited first!");
10707 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10708 return nativeResponseValue;
10710 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10712 export function CResult_RecoverableSignatureNoneZ_err(): number {
10713 if(!isWasmInitialized) {
10714 throw new Error("initializeWasm() must be awaited first!");
10716 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10717 return nativeResponseValue;
10719 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10721 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
10722 if(!isWasmInitialized) {
10723 throw new Error("initializeWasm() must be awaited first!");
10725 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10726 return nativeResponseValue;
10728 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10730 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
10731 if(!isWasmInitialized) {
10732 throw new Error("initializeWasm() must be awaited first!");
10734 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10735 // debug statements here
10737 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10739 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
10740 if(!isWasmInitialized) {
10741 throw new Error("initializeWasm() must be awaited first!");
10743 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10744 return nativeResponseValue;
10746 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10748 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
10749 if(!isWasmInitialized) {
10750 throw new Error("initializeWasm() must be awaited first!");
10752 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10753 return nativeResponseValue;
10755 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10757 export function CVec_u8Z_free(_res: number): void {
10758 if(!isWasmInitialized) {
10759 throw new Error("initializeWasm() must be awaited first!");
10761 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10762 // debug statements here
10764 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10766 export function CVec_CVec_u8ZZ_free(_res: number): void {
10767 if(!isWasmInitialized) {
10768 throw new Error("initializeWasm() must be awaited first!");
10770 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10771 // debug statements here
10773 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10775 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
10776 if(!isWasmInitialized) {
10777 throw new Error("initializeWasm() must be awaited first!");
10779 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10780 return nativeResponseValue;
10782 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10784 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
10785 if(!isWasmInitialized) {
10786 throw new Error("initializeWasm() must be awaited first!");
10788 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10789 return nativeResponseValue;
10791 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10793 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
10794 if(!isWasmInitialized) {
10795 throw new Error("initializeWasm() must be awaited first!");
10797 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10798 return nativeResponseValue;
10800 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10802 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
10803 if(!isWasmInitialized) {
10804 throw new Error("initializeWasm() must be awaited first!");
10806 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10807 // debug statements here
10809 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10811 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
10812 if(!isWasmInitialized) {
10813 throw new Error("initializeWasm() must be awaited first!");
10815 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10816 return nativeResponseValue;
10818 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10820 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
10821 if(!isWasmInitialized) {
10822 throw new Error("initializeWasm() must be awaited first!");
10824 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10825 return nativeResponseValue;
10827 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10829 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
10830 if(!isWasmInitialized) {
10831 throw new Error("initializeWasm() must be awaited first!");
10833 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10834 return nativeResponseValue;
10836 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10838 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
10839 if(!isWasmInitialized) {
10840 throw new Error("initializeWasm() must be awaited first!");
10842 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10843 return nativeResponseValue;
10845 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10847 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
10848 if(!isWasmInitialized) {
10849 throw new Error("initializeWasm() must be awaited first!");
10851 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10852 return nativeResponseValue;
10854 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10856 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
10857 if(!isWasmInitialized) {
10858 throw new Error("initializeWasm() must be awaited first!");
10860 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10861 // debug statements here
10863 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10865 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
10866 if(!isWasmInitialized) {
10867 throw new Error("initializeWasm() must be awaited first!");
10869 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10870 return nativeResponseValue;
10872 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10874 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
10875 if(!isWasmInitialized) {
10876 throw new Error("initializeWasm() must be awaited first!");
10878 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10879 return nativeResponseValue;
10881 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10883 export function CVec_TxOutZ_free(_res: number): void {
10884 if(!isWasmInitialized) {
10885 throw new Error("initializeWasm() must be awaited first!");
10887 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10888 // debug statements here
10890 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10892 export function CResult_TransactionNoneZ_ok(o: number): number {
10893 if(!isWasmInitialized) {
10894 throw new Error("initializeWasm() must be awaited first!");
10896 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10897 return nativeResponseValue;
10899 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10901 export function CResult_TransactionNoneZ_err(): number {
10902 if(!isWasmInitialized) {
10903 throw new Error("initializeWasm() must be awaited first!");
10905 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10906 return nativeResponseValue;
10908 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10910 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
10911 if(!isWasmInitialized) {
10912 throw new Error("initializeWasm() must be awaited first!");
10914 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10915 return nativeResponseValue;
10917 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10919 export function CResult_TransactionNoneZ_free(_res: number): void {
10920 if(!isWasmInitialized) {
10921 throw new Error("initializeWasm() must be awaited first!");
10923 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10924 // debug statements here
10926 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10928 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
10929 if(!isWasmInitialized) {
10930 throw new Error("initializeWasm() must be awaited first!");
10932 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10933 return nativeResponseValue;
10935 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10937 export function CResult_TransactionNoneZ_clone(orig: number): number {
10938 if(!isWasmInitialized) {
10939 throw new Error("initializeWasm() must be awaited first!");
10941 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10942 return nativeResponseValue;
10944 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10946 export function COption_u16Z_some(o: number): number {
10947 if(!isWasmInitialized) {
10948 throw new Error("initializeWasm() must be awaited first!");
10950 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10951 return nativeResponseValue;
10953 // struct LDKCOption_u16Z COption_u16Z_none(void);
10955 export function COption_u16Z_none(): number {
10956 if(!isWasmInitialized) {
10957 throw new Error("initializeWasm() must be awaited first!");
10959 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10960 return nativeResponseValue;
10962 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10964 export function COption_u16Z_free(_res: number): void {
10965 if(!isWasmInitialized) {
10966 throw new Error("initializeWasm() must be awaited first!");
10968 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10969 // debug statements here
10971 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10973 export function COption_u16Z_clone_ptr(arg: number): number {
10974 if(!isWasmInitialized) {
10975 throw new Error("initializeWasm() must be awaited first!");
10977 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10978 return nativeResponseValue;
10980 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10982 export function COption_u16Z_clone(orig: number): number {
10983 if(!isWasmInitialized) {
10984 throw new Error("initializeWasm() must be awaited first!");
10986 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10987 return nativeResponseValue;
10989 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10991 export function CResult_NoneAPIErrorZ_ok(): number {
10992 if(!isWasmInitialized) {
10993 throw new Error("initializeWasm() must be awaited first!");
10995 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10996 return nativeResponseValue;
10998 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11000 export function CResult_NoneAPIErrorZ_err(e: number): number {
11001 if(!isWasmInitialized) {
11002 throw new Error("initializeWasm() must be awaited first!");
11004 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11005 return nativeResponseValue;
11007 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11009 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
11010 if(!isWasmInitialized) {
11011 throw new Error("initializeWasm() must be awaited first!");
11013 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11014 return nativeResponseValue;
11016 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11018 export function CResult_NoneAPIErrorZ_free(_res: number): void {
11019 if(!isWasmInitialized) {
11020 throw new Error("initializeWasm() must be awaited first!");
11022 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11023 // debug statements here
11025 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11027 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
11028 if(!isWasmInitialized) {
11029 throw new Error("initializeWasm() must be awaited first!");
11031 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11032 return nativeResponseValue;
11034 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11036 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
11037 if(!isWasmInitialized) {
11038 throw new Error("initializeWasm() must be awaited first!");
11040 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11041 return nativeResponseValue;
11043 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11045 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11046 if(!isWasmInitialized) {
11047 throw new Error("initializeWasm() must be awaited first!");
11049 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11050 // debug statements here
11052 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11054 export function CVec_APIErrorZ_free(_res: number): void {
11055 if(!isWasmInitialized) {
11056 throw new Error("initializeWasm() must be awaited first!");
11058 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11059 // debug statements here
11061 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11063 export function CResult__u832APIErrorZ_ok(o: number): number {
11064 if(!isWasmInitialized) {
11065 throw new Error("initializeWasm() must be awaited first!");
11067 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11068 return nativeResponseValue;
11070 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11072 export function CResult__u832APIErrorZ_err(e: number): number {
11073 if(!isWasmInitialized) {
11074 throw new Error("initializeWasm() must be awaited first!");
11076 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11077 return nativeResponseValue;
11079 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11081 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
11082 if(!isWasmInitialized) {
11083 throw new Error("initializeWasm() must be awaited first!");
11085 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11086 return nativeResponseValue;
11088 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11090 export function CResult__u832APIErrorZ_free(_res: number): void {
11091 if(!isWasmInitialized) {
11092 throw new Error("initializeWasm() must be awaited first!");
11094 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11095 // debug statements here
11097 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11099 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
11100 if(!isWasmInitialized) {
11101 throw new Error("initializeWasm() must be awaited first!");
11103 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11104 return nativeResponseValue;
11106 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11108 export function CResult__u832APIErrorZ_clone(orig: number): number {
11109 if(!isWasmInitialized) {
11110 throw new Error("initializeWasm() must be awaited first!");
11112 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
11113 return nativeResponseValue;
11115 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
11117 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
11118 if(!isWasmInitialized) {
11119 throw new Error("initializeWasm() must be awaited first!");
11121 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
11122 return nativeResponseValue;
11124 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11126 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
11127 if(!isWasmInitialized) {
11128 throw new Error("initializeWasm() must be awaited first!");
11130 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
11131 return nativeResponseValue;
11133 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
11135 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
11136 if(!isWasmInitialized) {
11137 throw new Error("initializeWasm() must be awaited first!");
11139 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
11140 return nativeResponseValue;
11142 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
11144 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
11145 if(!isWasmInitialized) {
11146 throw new Error("initializeWasm() must be awaited first!");
11148 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
11149 // debug statements here
11151 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
11153 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
11154 if(!isWasmInitialized) {
11155 throw new Error("initializeWasm() must be awaited first!");
11157 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
11158 return nativeResponseValue;
11160 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
11162 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
11163 if(!isWasmInitialized) {
11164 throw new Error("initializeWasm() must be awaited first!");
11166 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
11167 return nativeResponseValue;
11169 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
11171 export function CResult_NonePaymentSendFailureZ_ok(): number {
11172 if(!isWasmInitialized) {
11173 throw new Error("initializeWasm() must be awaited first!");
11175 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
11176 return nativeResponseValue;
11178 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11180 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
11181 if(!isWasmInitialized) {
11182 throw new Error("initializeWasm() must be awaited first!");
11184 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
11185 return nativeResponseValue;
11187 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
11189 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
11190 if(!isWasmInitialized) {
11191 throw new Error("initializeWasm() must be awaited first!");
11193 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
11194 return nativeResponseValue;
11196 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
11198 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
11199 if(!isWasmInitialized) {
11200 throw new Error("initializeWasm() must be awaited first!");
11202 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
11203 // debug statements here
11205 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
11207 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
11208 if(!isWasmInitialized) {
11209 throw new Error("initializeWasm() must be awaited first!");
11211 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
11212 return nativeResponseValue;
11214 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
11216 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
11217 if(!isWasmInitialized) {
11218 throw new Error("initializeWasm() must be awaited first!");
11220 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
11221 return nativeResponseValue;
11223 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
11225 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
11226 if(!isWasmInitialized) {
11227 throw new Error("initializeWasm() must be awaited first!");
11229 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
11230 return nativeResponseValue;
11232 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
11234 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
11235 if(!isWasmInitialized) {
11236 throw new Error("initializeWasm() must be awaited first!");
11238 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
11239 return nativeResponseValue;
11241 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11243 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
11244 if(!isWasmInitialized) {
11245 throw new Error("initializeWasm() must be awaited first!");
11247 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
11248 return nativeResponseValue;
11250 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
11252 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
11253 if(!isWasmInitialized) {
11254 throw new Error("initializeWasm() must be awaited first!");
11256 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
11257 // debug statements here
11259 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
11261 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
11262 if(!isWasmInitialized) {
11263 throw new Error("initializeWasm() must be awaited first!");
11265 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
11266 return nativeResponseValue;
11268 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11270 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
11271 if(!isWasmInitialized) {
11272 throw new Error("initializeWasm() must be awaited first!");
11274 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
11275 return nativeResponseValue;
11277 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
11279 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
11280 if(!isWasmInitialized) {
11281 throw new Error("initializeWasm() must be awaited first!");
11283 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
11284 return nativeResponseValue;
11286 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
11288 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
11289 if(!isWasmInitialized) {
11290 throw new Error("initializeWasm() must be awaited first!");
11292 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
11293 // debug statements here
11295 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
11297 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
11298 if(!isWasmInitialized) {
11299 throw new Error("initializeWasm() must be awaited first!");
11301 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
11302 return nativeResponseValue;
11304 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
11306 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
11307 if(!isWasmInitialized) {
11308 throw new Error("initializeWasm() must be awaited first!");
11310 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
11311 return nativeResponseValue;
11313 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
11315 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
11316 if(!isWasmInitialized) {
11317 throw new Error("initializeWasm() must be awaited first!");
11319 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
11320 // debug statements here
11322 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
11324 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
11325 if(!isWasmInitialized) {
11326 throw new Error("initializeWasm() must be awaited first!");
11328 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
11329 return nativeResponseValue;
11331 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
11333 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
11334 if(!isWasmInitialized) {
11335 throw new Error("initializeWasm() must be awaited first!");
11337 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
11338 return nativeResponseValue;
11340 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11342 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
11343 if(!isWasmInitialized) {
11344 throw new Error("initializeWasm() must be awaited first!");
11346 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
11347 return nativeResponseValue;
11349 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11351 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
11352 if(!isWasmInitialized) {
11353 throw new Error("initializeWasm() must be awaited first!");
11355 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11356 // debug statements here
11358 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11360 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
11361 if(!isWasmInitialized) {
11362 throw new Error("initializeWasm() must be awaited first!");
11364 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11365 return nativeResponseValue;
11367 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11369 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
11370 if(!isWasmInitialized) {
11371 throw new Error("initializeWasm() must be awaited first!");
11373 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11374 return nativeResponseValue;
11376 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11378 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
11379 if(!isWasmInitialized) {
11380 throw new Error("initializeWasm() must be awaited first!");
11382 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11383 return nativeResponseValue;
11385 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11387 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
11388 if(!isWasmInitialized) {
11389 throw new Error("initializeWasm() must be awaited first!");
11391 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11392 // debug statements here
11394 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11396 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
11397 if(!isWasmInitialized) {
11398 throw new Error("initializeWasm() must be awaited first!");
11400 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11401 return nativeResponseValue;
11403 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11405 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
11406 if(!isWasmInitialized) {
11407 throw new Error("initializeWasm() must be awaited first!");
11409 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11410 return nativeResponseValue;
11412 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11414 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
11415 if(!isWasmInitialized) {
11416 throw new Error("initializeWasm() must be awaited first!");
11418 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11419 return nativeResponseValue;
11421 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11423 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
11424 if(!isWasmInitialized) {
11425 throw new Error("initializeWasm() must be awaited first!");
11427 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11428 return nativeResponseValue;
11430 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11432 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
11433 if(!isWasmInitialized) {
11434 throw new Error("initializeWasm() must be awaited first!");
11436 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11437 return nativeResponseValue;
11439 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
11441 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
11442 if(!isWasmInitialized) {
11443 throw new Error("initializeWasm() must be awaited first!");
11445 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
11446 // debug statements here
11448 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
11450 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
11451 if(!isWasmInitialized) {
11452 throw new Error("initializeWasm() must be awaited first!");
11454 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
11455 return nativeResponseValue;
11457 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
11459 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
11460 if(!isWasmInitialized) {
11461 throw new Error("initializeWasm() must be awaited first!");
11463 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
11464 return nativeResponseValue;
11466 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11468 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
11469 if(!isWasmInitialized) {
11470 throw new Error("initializeWasm() must be awaited first!");
11472 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
11473 return nativeResponseValue;
11475 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
11477 export function CResult_PaymentSecretNoneZ_err(): number {
11478 if(!isWasmInitialized) {
11479 throw new Error("initializeWasm() must be awaited first!");
11481 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
11482 return nativeResponseValue;
11484 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
11486 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
11487 if(!isWasmInitialized) {
11488 throw new Error("initializeWasm() must be awaited first!");
11490 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
11491 return nativeResponseValue;
11493 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
11495 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
11496 if(!isWasmInitialized) {
11497 throw new Error("initializeWasm() must be awaited first!");
11499 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
11500 // debug statements here
11502 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
11504 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
11505 if(!isWasmInitialized) {
11506 throw new Error("initializeWasm() must be awaited first!");
11508 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
11509 return nativeResponseValue;
11511 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
11513 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
11514 if(!isWasmInitialized) {
11515 throw new Error("initializeWasm() must be awaited first!");
11517 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
11518 return nativeResponseValue;
11520 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11522 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
11523 if(!isWasmInitialized) {
11524 throw new Error("initializeWasm() must be awaited first!");
11526 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
11527 return nativeResponseValue;
11529 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
11531 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
11532 if(!isWasmInitialized) {
11533 throw new Error("initializeWasm() must be awaited first!");
11535 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
11536 return nativeResponseValue;
11538 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
11540 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
11541 if(!isWasmInitialized) {
11542 throw new Error("initializeWasm() must be awaited first!");
11544 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
11545 return nativeResponseValue;
11547 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
11549 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
11550 if(!isWasmInitialized) {
11551 throw new Error("initializeWasm() must be awaited first!");
11553 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
11554 // debug statements here
11556 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
11558 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
11559 if(!isWasmInitialized) {
11560 throw new Error("initializeWasm() must be awaited first!");
11562 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
11563 return nativeResponseValue;
11565 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11567 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
11568 if(!isWasmInitialized) {
11569 throw new Error("initializeWasm() must be awaited first!");
11571 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11572 return nativeResponseValue;
11574 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11576 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
11577 if(!isWasmInitialized) {
11578 throw new Error("initializeWasm() must be awaited first!");
11580 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11581 return nativeResponseValue;
11583 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11585 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
11586 if(!isWasmInitialized) {
11587 throw new Error("initializeWasm() must be awaited first!");
11589 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11590 return nativeResponseValue;
11592 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11594 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
11595 if(!isWasmInitialized) {
11596 throw new Error("initializeWasm() must be awaited first!");
11598 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11599 return nativeResponseValue;
11601 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11603 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
11604 if(!isWasmInitialized) {
11605 throw new Error("initializeWasm() must be awaited first!");
11607 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11608 // debug statements here
11610 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11612 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
11613 if(!isWasmInitialized) {
11614 throw new Error("initializeWasm() must be awaited first!");
11616 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11617 return nativeResponseValue;
11619 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11621 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
11622 if(!isWasmInitialized) {
11623 throw new Error("initializeWasm() must be awaited first!");
11625 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11626 return nativeResponseValue;
11628 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11630 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
11631 if(!isWasmInitialized) {
11632 throw new Error("initializeWasm() must be awaited first!");
11634 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11635 return nativeResponseValue;
11637 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11639 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
11640 if(!isWasmInitialized) {
11641 throw new Error("initializeWasm() must be awaited first!");
11643 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11644 return nativeResponseValue;
11646 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11648 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
11649 if(!isWasmInitialized) {
11650 throw new Error("initializeWasm() must be awaited first!");
11652 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11653 return nativeResponseValue;
11655 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11657 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
11658 if(!isWasmInitialized) {
11659 throw new Error("initializeWasm() must be awaited first!");
11661 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11662 // debug statements here
11664 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11666 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
11667 if(!isWasmInitialized) {
11668 throw new Error("initializeWasm() must be awaited first!");
11670 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11671 return nativeResponseValue;
11673 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11675 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
11676 if(!isWasmInitialized) {
11677 throw new Error("initializeWasm() must be awaited first!");
11679 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11680 return nativeResponseValue;
11682 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11684 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
11685 if(!isWasmInitialized) {
11686 throw new Error("initializeWasm() must be awaited first!");
11688 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11689 return nativeResponseValue;
11691 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11693 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
11694 if(!isWasmInitialized) {
11695 throw new Error("initializeWasm() must be awaited first!");
11697 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11698 return nativeResponseValue;
11700 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11702 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
11703 if(!isWasmInitialized) {
11704 throw new Error("initializeWasm() must be awaited first!");
11706 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11707 return nativeResponseValue;
11709 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11711 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
11712 if(!isWasmInitialized) {
11713 throw new Error("initializeWasm() must be awaited first!");
11715 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11716 // debug statements here
11718 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11720 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
11721 if(!isWasmInitialized) {
11722 throw new Error("initializeWasm() must be awaited first!");
11724 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11725 return nativeResponseValue;
11727 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11729 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
11730 if(!isWasmInitialized) {
11731 throw new Error("initializeWasm() must be awaited first!");
11733 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11734 return nativeResponseValue;
11736 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11738 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
11739 if(!isWasmInitialized) {
11740 throw new Error("initializeWasm() must be awaited first!");
11742 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11743 return nativeResponseValue;
11745 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11747 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
11748 if(!isWasmInitialized) {
11749 throw new Error("initializeWasm() must be awaited first!");
11751 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11752 return nativeResponseValue;
11754 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11756 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
11757 if(!isWasmInitialized) {
11758 throw new Error("initializeWasm() must be awaited first!");
11760 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11761 return nativeResponseValue;
11763 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11765 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
11766 if(!isWasmInitialized) {
11767 throw new Error("initializeWasm() must be awaited first!");
11769 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11770 // debug statements here
11772 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11774 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
11775 if(!isWasmInitialized) {
11776 throw new Error("initializeWasm() must be awaited first!");
11778 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11779 return nativeResponseValue;
11781 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11783 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
11784 if(!isWasmInitialized) {
11785 throw new Error("initializeWasm() must be awaited first!");
11787 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11788 return nativeResponseValue;
11790 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11792 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
11793 if(!isWasmInitialized) {
11794 throw new Error("initializeWasm() must be awaited first!");
11796 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11797 return nativeResponseValue;
11799 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11801 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
11802 if(!isWasmInitialized) {
11803 throw new Error("initializeWasm() must be awaited first!");
11805 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11806 return nativeResponseValue;
11808 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11810 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
11811 if(!isWasmInitialized) {
11812 throw new Error("initializeWasm() must be awaited first!");
11814 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11815 return nativeResponseValue;
11817 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11819 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
11820 if(!isWasmInitialized) {
11821 throw new Error("initializeWasm() must be awaited first!");
11823 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11824 // debug statements here
11826 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11828 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
11829 if(!isWasmInitialized) {
11830 throw new Error("initializeWasm() must be awaited first!");
11832 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11833 return nativeResponseValue;
11835 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11837 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
11838 if(!isWasmInitialized) {
11839 throw new Error("initializeWasm() must be awaited first!");
11841 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11842 return nativeResponseValue;
11844 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11846 export function CVec_ChannelMonitorZ_free(_res: number): void {
11847 if(!isWasmInitialized) {
11848 throw new Error("initializeWasm() must be awaited first!");
11850 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11851 // debug statements here
11853 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11855 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
11856 if(!isWasmInitialized) {
11857 throw new Error("initializeWasm() must be awaited first!");
11859 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11860 return nativeResponseValue;
11862 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11864 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
11865 if(!isWasmInitialized) {
11866 throw new Error("initializeWasm() must be awaited first!");
11868 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11869 // debug statements here
11871 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11873 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
11874 if(!isWasmInitialized) {
11875 throw new Error("initializeWasm() must be awaited first!");
11877 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11878 return nativeResponseValue;
11880 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11882 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
11883 if(!isWasmInitialized) {
11884 throw new Error("initializeWasm() must be awaited first!");
11886 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11887 return nativeResponseValue;
11889 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11891 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
11892 if(!isWasmInitialized) {
11893 throw new Error("initializeWasm() must be awaited first!");
11895 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11896 return nativeResponseValue;
11898 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11900 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
11901 if(!isWasmInitialized) {
11902 throw new Error("initializeWasm() must be awaited first!");
11904 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11905 // debug statements here
11907 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11909 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
11910 if(!isWasmInitialized) {
11911 throw new Error("initializeWasm() must be awaited first!");
11913 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11914 return nativeResponseValue;
11916 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11918 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
11919 if(!isWasmInitialized) {
11920 throw new Error("initializeWasm() must be awaited first!");
11922 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11923 return nativeResponseValue;
11925 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11927 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
11928 if(!isWasmInitialized) {
11929 throw new Error("initializeWasm() must be awaited first!");
11931 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11932 return nativeResponseValue;
11934 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11936 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
11937 if(!isWasmInitialized) {
11938 throw new Error("initializeWasm() must be awaited first!");
11940 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11941 // debug statements here
11943 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11945 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
11946 if(!isWasmInitialized) {
11947 throw new Error("initializeWasm() must be awaited first!");
11949 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11950 return nativeResponseValue;
11952 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11954 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
11955 if(!isWasmInitialized) {
11956 throw new Error("initializeWasm() must be awaited first!");
11958 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11959 return nativeResponseValue;
11961 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11963 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
11964 if(!isWasmInitialized) {
11965 throw new Error("initializeWasm() must be awaited first!");
11967 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11968 return nativeResponseValue;
11970 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11972 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
11973 if(!isWasmInitialized) {
11974 throw new Error("initializeWasm() must be awaited first!");
11976 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11977 return nativeResponseValue;
11979 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11981 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
11982 if(!isWasmInitialized) {
11983 throw new Error("initializeWasm() must be awaited first!");
11985 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11986 return nativeResponseValue;
11988 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11990 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
11991 if(!isWasmInitialized) {
11992 throw new Error("initializeWasm() must be awaited first!");
11994 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
11995 // debug statements here
11997 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
11999 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
12000 if(!isWasmInitialized) {
12001 throw new Error("initializeWasm() must be awaited first!");
12003 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
12004 return nativeResponseValue;
12006 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
12008 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
12009 if(!isWasmInitialized) {
12010 throw new Error("initializeWasm() must be awaited first!");
12012 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
12013 return nativeResponseValue;
12015 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
12017 export function COption_TypeZ_some(o: number): number {
12018 if(!isWasmInitialized) {
12019 throw new Error("initializeWasm() must be awaited first!");
12021 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
12022 return nativeResponseValue;
12024 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
12026 export function COption_TypeZ_none(): number {
12027 if(!isWasmInitialized) {
12028 throw new Error("initializeWasm() must be awaited first!");
12030 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
12031 return nativeResponseValue;
12033 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
12035 export function COption_TypeZ_free(_res: number): void {
12036 if(!isWasmInitialized) {
12037 throw new Error("initializeWasm() must be awaited first!");
12039 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
12040 // debug statements here
12042 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
12044 export function COption_TypeZ_clone_ptr(arg: number): number {
12045 if(!isWasmInitialized) {
12046 throw new Error("initializeWasm() must be awaited first!");
12048 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
12049 return nativeResponseValue;
12051 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
12053 export function COption_TypeZ_clone(orig: number): number {
12054 if(!isWasmInitialized) {
12055 throw new Error("initializeWasm() must be awaited first!");
12057 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
12058 return nativeResponseValue;
12060 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
12062 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
12063 if(!isWasmInitialized) {
12064 throw new Error("initializeWasm() must be awaited first!");
12066 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
12067 return nativeResponseValue;
12069 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
12071 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
12072 if(!isWasmInitialized) {
12073 throw new Error("initializeWasm() must be awaited first!");
12075 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
12076 return nativeResponseValue;
12078 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
12080 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
12081 if(!isWasmInitialized) {
12082 throw new Error("initializeWasm() must be awaited first!");
12084 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
12085 return nativeResponseValue;
12087 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
12089 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
12090 if(!isWasmInitialized) {
12091 throw new Error("initializeWasm() must be awaited first!");
12093 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
12094 // debug statements here
12096 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
12098 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
12099 if(!isWasmInitialized) {
12100 throw new Error("initializeWasm() must be awaited first!");
12102 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
12103 return nativeResponseValue;
12105 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
12107 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
12108 if(!isWasmInitialized) {
12109 throw new Error("initializeWasm() must be awaited first!");
12111 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
12112 return nativeResponseValue;
12114 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
12116 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
12117 if(!isWasmInitialized) {
12118 throw new Error("initializeWasm() must be awaited first!");
12120 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
12121 return nativeResponseValue;
12123 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
12125 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
12126 if(!isWasmInitialized) {
12127 throw new Error("initializeWasm() must be awaited first!");
12129 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
12130 return nativeResponseValue;
12132 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
12134 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
12135 if(!isWasmInitialized) {
12136 throw new Error("initializeWasm() must be awaited first!");
12138 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
12139 return nativeResponseValue;
12141 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
12143 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
12144 if(!isWasmInitialized) {
12145 throw new Error("initializeWasm() must be awaited first!");
12147 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
12148 // debug statements here
12150 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
12152 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
12153 if(!isWasmInitialized) {
12154 throw new Error("initializeWasm() must be awaited first!");
12156 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
12157 return nativeResponseValue;
12159 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
12161 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
12162 if(!isWasmInitialized) {
12163 throw new Error("initializeWasm() must be awaited first!");
12165 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
12166 return nativeResponseValue;
12168 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
12170 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
12171 if(!isWasmInitialized) {
12172 throw new Error("initializeWasm() must be awaited first!");
12174 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
12175 return nativeResponseValue;
12177 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
12179 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
12180 if(!isWasmInitialized) {
12181 throw new Error("initializeWasm() must be awaited first!");
12183 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
12184 return nativeResponseValue;
12186 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
12188 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
12189 if(!isWasmInitialized) {
12190 throw new Error("initializeWasm() must be awaited first!");
12192 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
12193 return nativeResponseValue;
12195 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
12197 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
12198 if(!isWasmInitialized) {
12199 throw new Error("initializeWasm() must be awaited first!");
12201 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
12202 // debug statements here
12204 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
12206 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
12207 if(!isWasmInitialized) {
12208 throw new Error("initializeWasm() must be awaited first!");
12210 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
12211 return nativeResponseValue;
12213 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
12215 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
12216 if(!isWasmInitialized) {
12217 throw new Error("initializeWasm() must be awaited first!");
12219 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
12220 return nativeResponseValue;
12222 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
12224 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
12225 if(!isWasmInitialized) {
12226 throw new Error("initializeWasm() must be awaited first!");
12228 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
12229 return nativeResponseValue;
12231 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
12233 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
12234 if(!isWasmInitialized) {
12235 throw new Error("initializeWasm() must be awaited first!");
12237 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
12238 return nativeResponseValue;
12240 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
12242 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
12243 if(!isWasmInitialized) {
12244 throw new Error("initializeWasm() must be awaited first!");
12246 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
12247 return nativeResponseValue;
12249 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
12251 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
12252 if(!isWasmInitialized) {
12253 throw new Error("initializeWasm() must be awaited first!");
12255 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
12256 // debug statements here
12258 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
12260 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
12261 if(!isWasmInitialized) {
12262 throw new Error("initializeWasm() must be awaited first!");
12264 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
12265 return nativeResponseValue;
12267 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
12269 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
12270 if(!isWasmInitialized) {
12271 throw new Error("initializeWasm() must be awaited first!");
12273 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
12274 return nativeResponseValue;
12276 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
12278 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
12279 if(!isWasmInitialized) {
12280 throw new Error("initializeWasm() must be awaited first!");
12282 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
12283 return nativeResponseValue;
12285 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
12287 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
12288 if(!isWasmInitialized) {
12289 throw new Error("initializeWasm() must be awaited first!");
12291 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
12292 return nativeResponseValue;
12294 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
12296 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
12297 if(!isWasmInitialized) {
12298 throw new Error("initializeWasm() must be awaited first!");
12300 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
12301 return nativeResponseValue;
12303 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
12305 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
12306 if(!isWasmInitialized) {
12307 throw new Error("initializeWasm() must be awaited first!");
12309 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
12310 // debug statements here
12312 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
12314 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
12315 if(!isWasmInitialized) {
12316 throw new Error("initializeWasm() must be awaited first!");
12318 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
12319 return nativeResponseValue;
12321 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
12323 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
12324 if(!isWasmInitialized) {
12325 throw new Error("initializeWasm() must be awaited first!");
12327 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
12328 return nativeResponseValue;
12330 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
12332 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
12333 if(!isWasmInitialized) {
12334 throw new Error("initializeWasm() must be awaited first!");
12336 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
12337 return nativeResponseValue;
12339 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
12341 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
12342 if(!isWasmInitialized) {
12343 throw new Error("initializeWasm() must be awaited first!");
12345 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
12346 return nativeResponseValue;
12348 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
12350 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
12351 if(!isWasmInitialized) {
12352 throw new Error("initializeWasm() must be awaited first!");
12354 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
12355 return nativeResponseValue;
12357 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
12359 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
12360 if(!isWasmInitialized) {
12361 throw new Error("initializeWasm() must be awaited first!");
12363 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
12364 // debug statements here
12366 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
12368 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
12369 if(!isWasmInitialized) {
12370 throw new Error("initializeWasm() must be awaited first!");
12372 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
12373 return nativeResponseValue;
12375 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
12377 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
12378 if(!isWasmInitialized) {
12379 throw new Error("initializeWasm() must be awaited first!");
12381 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
12382 return nativeResponseValue;
12384 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
12386 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
12387 if(!isWasmInitialized) {
12388 throw new Error("initializeWasm() must be awaited first!");
12390 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
12391 return nativeResponseValue;
12393 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
12395 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
12396 if(!isWasmInitialized) {
12397 throw new Error("initializeWasm() must be awaited first!");
12399 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
12400 // debug statements here
12402 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
12404 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
12405 if(!isWasmInitialized) {
12406 throw new Error("initializeWasm() must be awaited first!");
12408 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
12409 return nativeResponseValue;
12411 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
12413 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
12414 if(!isWasmInitialized) {
12415 throw new Error("initializeWasm() must be awaited first!");
12417 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
12418 return nativeResponseValue;
12420 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
12422 export function CVec_PrivateRouteZ_free(_res: number): void {
12423 if(!isWasmInitialized) {
12424 throw new Error("initializeWasm() must be awaited first!");
12426 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
12427 // debug statements here
12429 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
12431 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
12432 if(!isWasmInitialized) {
12433 throw new Error("initializeWasm() must be awaited first!");
12435 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
12436 return nativeResponseValue;
12438 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
12440 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
12441 if(!isWasmInitialized) {
12442 throw new Error("initializeWasm() must be awaited first!");
12444 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
12445 return nativeResponseValue;
12447 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
12449 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
12450 if(!isWasmInitialized) {
12451 throw new Error("initializeWasm() must be awaited first!");
12453 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
12454 return nativeResponseValue;
12456 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
12458 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
12459 if(!isWasmInitialized) {
12460 throw new Error("initializeWasm() must be awaited first!");
12462 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
12463 // debug statements here
12465 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
12467 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
12468 if(!isWasmInitialized) {
12469 throw new Error("initializeWasm() must be awaited first!");
12471 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
12472 return nativeResponseValue;
12474 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
12476 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
12477 if(!isWasmInitialized) {
12478 throw new Error("initializeWasm() must be awaited first!");
12480 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
12481 return nativeResponseValue;
12483 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
12485 export function CResult_NoneSemanticErrorZ_ok(): number {
12486 if(!isWasmInitialized) {
12487 throw new Error("initializeWasm() must be awaited first!");
12489 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
12490 return nativeResponseValue;
12492 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
12494 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
12495 if(!isWasmInitialized) {
12496 throw new Error("initializeWasm() must be awaited first!");
12498 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
12499 return nativeResponseValue;
12501 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
12503 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
12504 if(!isWasmInitialized) {
12505 throw new Error("initializeWasm() must be awaited first!");
12507 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
12508 return nativeResponseValue;
12510 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
12512 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
12513 if(!isWasmInitialized) {
12514 throw new Error("initializeWasm() must be awaited first!");
12516 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
12517 // debug statements here
12519 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
12521 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
12522 if(!isWasmInitialized) {
12523 throw new Error("initializeWasm() must be awaited first!");
12525 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
12526 return nativeResponseValue;
12528 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
12530 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
12531 if(!isWasmInitialized) {
12532 throw new Error("initializeWasm() must be awaited first!");
12534 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
12535 return nativeResponseValue;
12537 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
12539 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
12540 if(!isWasmInitialized) {
12541 throw new Error("initializeWasm() must be awaited first!");
12543 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
12544 return nativeResponseValue;
12546 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
12548 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
12549 if(!isWasmInitialized) {
12550 throw new Error("initializeWasm() must be awaited first!");
12552 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
12553 return nativeResponseValue;
12555 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
12557 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
12558 if(!isWasmInitialized) {
12559 throw new Error("initializeWasm() must be awaited first!");
12561 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
12562 return nativeResponseValue;
12564 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
12566 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
12567 if(!isWasmInitialized) {
12568 throw new Error("initializeWasm() must be awaited first!");
12570 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12571 // debug statements here
12573 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12575 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
12576 if(!isWasmInitialized) {
12577 throw new Error("initializeWasm() must be awaited first!");
12579 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12580 return nativeResponseValue;
12582 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12584 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
12585 if(!isWasmInitialized) {
12586 throw new Error("initializeWasm() must be awaited first!");
12588 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12589 return nativeResponseValue;
12591 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12593 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
12594 if(!isWasmInitialized) {
12595 throw new Error("initializeWasm() must be awaited first!");
12597 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12598 return nativeResponseValue;
12600 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12602 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
12603 if(!isWasmInitialized) {
12604 throw new Error("initializeWasm() must be awaited first!");
12606 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12607 return nativeResponseValue;
12609 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12611 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
12612 if(!isWasmInitialized) {
12613 throw new Error("initializeWasm() must be awaited first!");
12615 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12616 return nativeResponseValue;
12618 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12620 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
12621 if(!isWasmInitialized) {
12622 throw new Error("initializeWasm() must be awaited first!");
12624 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12625 // debug statements here
12627 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12629 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
12630 if(!isWasmInitialized) {
12631 throw new Error("initializeWasm() must be awaited first!");
12633 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12634 return nativeResponseValue;
12636 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12638 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
12639 if(!isWasmInitialized) {
12640 throw new Error("initializeWasm() must be awaited first!");
12642 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12643 return nativeResponseValue;
12645 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12647 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
12648 if(!isWasmInitialized) {
12649 throw new Error("initializeWasm() must be awaited first!");
12651 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12652 return nativeResponseValue;
12654 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12656 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
12657 if(!isWasmInitialized) {
12658 throw new Error("initializeWasm() must be awaited first!");
12660 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12661 return nativeResponseValue;
12663 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12665 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
12666 if(!isWasmInitialized) {
12667 throw new Error("initializeWasm() must be awaited first!");
12669 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12670 return nativeResponseValue;
12672 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12674 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
12675 if(!isWasmInitialized) {
12676 throw new Error("initializeWasm() must be awaited first!");
12678 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12679 // debug statements here
12681 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12683 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
12684 if(!isWasmInitialized) {
12685 throw new Error("initializeWasm() must be awaited first!");
12687 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12688 return nativeResponseValue;
12690 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12692 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
12693 if(!isWasmInitialized) {
12694 throw new Error("initializeWasm() must be awaited first!");
12696 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12697 return nativeResponseValue;
12699 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12701 export function CResult_StringErrorZ_ok(o: number): number {
12702 if(!isWasmInitialized) {
12703 throw new Error("initializeWasm() must be awaited first!");
12705 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12706 return nativeResponseValue;
12708 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12710 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
12711 if(!isWasmInitialized) {
12712 throw new Error("initializeWasm() must be awaited first!");
12714 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12715 return nativeResponseValue;
12717 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12719 export function CResult_StringErrorZ_is_ok(o: number): boolean {
12720 if(!isWasmInitialized) {
12721 throw new Error("initializeWasm() must be awaited first!");
12723 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12724 return nativeResponseValue;
12726 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12728 export function CResult_StringErrorZ_free(_res: number): void {
12729 if(!isWasmInitialized) {
12730 throw new Error("initializeWasm() must be awaited first!");
12732 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12733 // debug statements here
12735 // uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12737 export function CResult_StringErrorZ_clone_ptr(arg: number): number {
12738 if(!isWasmInitialized) {
12739 throw new Error("initializeWasm() must be awaited first!");
12741 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12742 return nativeResponseValue;
12744 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12746 export function CResult_StringErrorZ_clone(orig: number): number {
12747 if(!isWasmInitialized) {
12748 throw new Error("initializeWasm() must be awaited first!");
12750 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12751 return nativeResponseValue;
12753 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12755 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
12756 if(!isWasmInitialized) {
12757 throw new Error("initializeWasm() must be awaited first!");
12759 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12760 return nativeResponseValue;
12762 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12764 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
12765 if(!isWasmInitialized) {
12766 throw new Error("initializeWasm() must be awaited first!");
12768 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12769 return nativeResponseValue;
12771 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12773 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
12774 if(!isWasmInitialized) {
12775 throw new Error("initializeWasm() must be awaited first!");
12777 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12778 return nativeResponseValue;
12780 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12782 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
12783 if(!isWasmInitialized) {
12784 throw new Error("initializeWasm() must be awaited first!");
12786 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12787 // debug statements here
12789 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12791 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12792 if(!isWasmInitialized) {
12793 throw new Error("initializeWasm() must be awaited first!");
12795 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12796 return nativeResponseValue;
12798 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12800 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
12801 if(!isWasmInitialized) {
12802 throw new Error("initializeWasm() must be awaited first!");
12804 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12805 return nativeResponseValue;
12807 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12809 export function COption_MonitorEventZ_some(o: number): number {
12810 if(!isWasmInitialized) {
12811 throw new Error("initializeWasm() must be awaited first!");
12813 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12814 return nativeResponseValue;
12816 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12818 export function COption_MonitorEventZ_none(): number {
12819 if(!isWasmInitialized) {
12820 throw new Error("initializeWasm() must be awaited first!");
12822 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12823 return nativeResponseValue;
12825 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12827 export function COption_MonitorEventZ_free(_res: number): void {
12828 if(!isWasmInitialized) {
12829 throw new Error("initializeWasm() must be awaited first!");
12831 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12832 // debug statements here
12834 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12836 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
12837 if(!isWasmInitialized) {
12838 throw new Error("initializeWasm() must be awaited first!");
12840 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12841 return nativeResponseValue;
12843 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12845 export function COption_MonitorEventZ_clone(orig: number): number {
12846 if(!isWasmInitialized) {
12847 throw new Error("initializeWasm() must be awaited first!");
12849 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12850 return nativeResponseValue;
12852 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12854 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
12855 if(!isWasmInitialized) {
12856 throw new Error("initializeWasm() must be awaited first!");
12858 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12859 return nativeResponseValue;
12861 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12863 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
12864 if(!isWasmInitialized) {
12865 throw new Error("initializeWasm() must be awaited first!");
12867 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12868 return nativeResponseValue;
12870 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12872 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
12873 if(!isWasmInitialized) {
12874 throw new Error("initializeWasm() must be awaited first!");
12876 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12877 return nativeResponseValue;
12879 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12881 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
12882 if(!isWasmInitialized) {
12883 throw new Error("initializeWasm() must be awaited first!");
12885 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12886 // debug statements here
12888 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12890 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
12891 if(!isWasmInitialized) {
12892 throw new Error("initializeWasm() must be awaited first!");
12894 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12895 return nativeResponseValue;
12897 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12899 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
12900 if(!isWasmInitialized) {
12901 throw new Error("initializeWasm() must be awaited first!");
12903 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12904 return nativeResponseValue;
12906 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12908 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
12909 if(!isWasmInitialized) {
12910 throw new Error("initializeWasm() must be awaited first!");
12912 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12913 return nativeResponseValue;
12915 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12917 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
12918 if(!isWasmInitialized) {
12919 throw new Error("initializeWasm() must be awaited first!");
12921 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12922 return nativeResponseValue;
12924 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12926 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
12927 if(!isWasmInitialized) {
12928 throw new Error("initializeWasm() must be awaited first!");
12930 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12931 return nativeResponseValue;
12933 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12935 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
12936 if(!isWasmInitialized) {
12937 throw new Error("initializeWasm() must be awaited first!");
12939 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12940 // debug statements here
12942 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12944 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12945 if(!isWasmInitialized) {
12946 throw new Error("initializeWasm() must be awaited first!");
12948 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12949 return nativeResponseValue;
12951 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12953 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
12954 if(!isWasmInitialized) {
12955 throw new Error("initializeWasm() must be awaited first!");
12957 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12958 return nativeResponseValue;
12960 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12962 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
12963 if(!isWasmInitialized) {
12964 throw new Error("initializeWasm() must be awaited first!");
12966 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12967 return nativeResponseValue;
12969 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12971 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
12972 if(!isWasmInitialized) {
12973 throw new Error("initializeWasm() must be awaited first!");
12975 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12976 return nativeResponseValue;
12978 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12980 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
12981 if(!isWasmInitialized) {
12982 throw new Error("initializeWasm() must be awaited first!");
12984 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12985 return nativeResponseValue;
12987 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12989 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
12990 if(!isWasmInitialized) {
12991 throw new Error("initializeWasm() must be awaited first!");
12993 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
12994 // debug statements here
12996 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
12998 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
12999 if(!isWasmInitialized) {
13000 throw new Error("initializeWasm() must be awaited first!");
13002 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
13003 return nativeResponseValue;
13005 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
13007 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
13008 if(!isWasmInitialized) {
13009 throw new Error("initializeWasm() must be awaited first!");
13011 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
13012 return nativeResponseValue;
13014 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
13016 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
13017 if(!isWasmInitialized) {
13018 throw new Error("initializeWasm() must be awaited first!");
13020 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
13021 return nativeResponseValue;
13023 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
13025 export function C2Tuple_u32ScriptZ_free(_res: number): void {
13026 if(!isWasmInitialized) {
13027 throw new Error("initializeWasm() must be awaited first!");
13029 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
13030 // debug statements here
13032 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
13034 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
13035 if(!isWasmInitialized) {
13036 throw new Error("initializeWasm() must be awaited first!");
13038 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
13039 // debug statements here
13041 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
13043 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
13044 if(!isWasmInitialized) {
13045 throw new Error("initializeWasm() must be awaited first!");
13047 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
13048 return nativeResponseValue;
13050 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
13052 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
13053 if(!isWasmInitialized) {
13054 throw new Error("initializeWasm() must be awaited first!");
13056 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
13057 return nativeResponseValue;
13059 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
13061 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
13062 if(!isWasmInitialized) {
13063 throw new Error("initializeWasm() must be awaited first!");
13065 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
13066 return nativeResponseValue;
13068 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
13070 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
13071 if(!isWasmInitialized) {
13072 throw new Error("initializeWasm() must be awaited first!");
13074 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
13075 // debug statements here
13077 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
13079 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
13080 if(!isWasmInitialized) {
13081 throw new Error("initializeWasm() must be awaited first!");
13083 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
13084 // debug statements here
13086 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
13088 export function CVec_EventZ_free(_res: number): void {
13089 if(!isWasmInitialized) {
13090 throw new Error("initializeWasm() must be awaited first!");
13092 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
13093 // debug statements here
13095 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
13097 export function CVec_TransactionZ_free(_res: number): void {
13098 if(!isWasmInitialized) {
13099 throw new Error("initializeWasm() must be awaited first!");
13101 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
13102 // debug statements here
13104 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
13106 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
13107 if(!isWasmInitialized) {
13108 throw new Error("initializeWasm() must be awaited first!");
13110 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
13111 return nativeResponseValue;
13113 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
13115 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
13116 if(!isWasmInitialized) {
13117 throw new Error("initializeWasm() must be awaited first!");
13119 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
13120 return nativeResponseValue;
13122 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
13124 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
13125 if(!isWasmInitialized) {
13126 throw new Error("initializeWasm() must be awaited first!");
13128 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
13129 return nativeResponseValue;
13131 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
13133 export function C2Tuple_u32TxOutZ_free(_res: number): void {
13134 if(!isWasmInitialized) {
13135 throw new Error("initializeWasm() must be awaited first!");
13137 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
13138 // debug statements here
13140 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
13142 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
13143 if(!isWasmInitialized) {
13144 throw new Error("initializeWasm() must be awaited first!");
13146 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
13147 // debug statements here
13149 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
13151 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
13152 if(!isWasmInitialized) {
13153 throw new Error("initializeWasm() must be awaited first!");
13155 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
13156 return nativeResponseValue;
13158 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
13160 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
13161 if(!isWasmInitialized) {
13162 throw new Error("initializeWasm() must be awaited first!");
13164 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
13165 return nativeResponseValue;
13167 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
13169 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
13170 if(!isWasmInitialized) {
13171 throw new Error("initializeWasm() must be awaited first!");
13173 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
13174 return nativeResponseValue;
13176 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
13178 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
13179 if(!isWasmInitialized) {
13180 throw new Error("initializeWasm() must be awaited first!");
13182 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
13183 // debug statements here
13185 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
13187 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
13188 if(!isWasmInitialized) {
13189 throw new Error("initializeWasm() must be awaited first!");
13191 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
13192 // debug statements here
13194 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
13196 export function CVec_BalanceZ_free(_res: number): void {
13197 if(!isWasmInitialized) {
13198 throw new Error("initializeWasm() must be awaited first!");
13200 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
13201 // debug statements here
13203 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
13205 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
13206 if(!isWasmInitialized) {
13207 throw new Error("initializeWasm() must be awaited first!");
13209 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
13210 return nativeResponseValue;
13212 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
13214 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
13215 if(!isWasmInitialized) {
13216 throw new Error("initializeWasm() must be awaited first!");
13218 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
13219 return nativeResponseValue;
13221 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
13223 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
13224 if(!isWasmInitialized) {
13225 throw new Error("initializeWasm() must be awaited first!");
13227 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
13228 return nativeResponseValue;
13230 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
13232 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
13233 if(!isWasmInitialized) {
13234 throw new Error("initializeWasm() must be awaited first!");
13236 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
13237 // debug statements here
13239 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
13241 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
13242 if(!isWasmInitialized) {
13243 throw new Error("initializeWasm() must be awaited first!");
13245 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
13246 return nativeResponseValue;
13248 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
13250 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
13251 if(!isWasmInitialized) {
13252 throw new Error("initializeWasm() must be awaited first!");
13254 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
13255 return nativeResponseValue;
13257 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
13259 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
13260 if(!isWasmInitialized) {
13261 throw new Error("initializeWasm() must be awaited first!");
13263 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
13264 return nativeResponseValue;
13266 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
13268 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
13269 if(!isWasmInitialized) {
13270 throw new Error("initializeWasm() must be awaited first!");
13272 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
13273 // debug statements here
13275 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
13277 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
13278 if(!isWasmInitialized) {
13279 throw new Error("initializeWasm() must be awaited first!");
13281 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
13282 return nativeResponseValue;
13284 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
13286 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
13287 if(!isWasmInitialized) {
13288 throw new Error("initializeWasm() must be awaited first!");
13290 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
13291 return nativeResponseValue;
13293 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
13295 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
13296 if(!isWasmInitialized) {
13297 throw new Error("initializeWasm() must be awaited first!");
13299 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
13300 return nativeResponseValue;
13302 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
13304 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
13305 if(!isWasmInitialized) {
13306 throw new Error("initializeWasm() must be awaited first!");
13308 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
13309 return nativeResponseValue;
13311 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
13313 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
13314 if(!isWasmInitialized) {
13315 throw new Error("initializeWasm() must be awaited first!");
13317 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
13318 return nativeResponseValue;
13320 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
13322 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
13323 if(!isWasmInitialized) {
13324 throw new Error("initializeWasm() must be awaited first!");
13326 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
13327 // debug statements here
13329 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
13331 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
13332 if(!isWasmInitialized) {
13333 throw new Error("initializeWasm() must be awaited first!");
13335 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
13336 // debug statements here
13338 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
13340 export function COption_NetAddressZ_some(o: number): number {
13341 if(!isWasmInitialized) {
13342 throw new Error("initializeWasm() must be awaited first!");
13344 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
13345 return nativeResponseValue;
13347 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
13349 export function COption_NetAddressZ_none(): number {
13350 if(!isWasmInitialized) {
13351 throw new Error("initializeWasm() must be awaited first!");
13353 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
13354 return nativeResponseValue;
13356 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
13358 export function COption_NetAddressZ_free(_res: number): void {
13359 if(!isWasmInitialized) {
13360 throw new Error("initializeWasm() must be awaited first!");
13362 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
13363 // debug statements here
13365 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
13367 export function COption_NetAddressZ_clone_ptr(arg: number): number {
13368 if(!isWasmInitialized) {
13369 throw new Error("initializeWasm() must be awaited first!");
13371 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
13372 return nativeResponseValue;
13374 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
13376 export function COption_NetAddressZ_clone(orig: number): number {
13377 if(!isWasmInitialized) {
13378 throw new Error("initializeWasm() must be awaited first!");
13380 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
13381 return nativeResponseValue;
13383 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
13385 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
13386 if(!isWasmInitialized) {
13387 throw new Error("initializeWasm() must be awaited first!");
13389 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
13390 return nativeResponseValue;
13392 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13394 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
13395 if(!isWasmInitialized) {
13396 throw new Error("initializeWasm() must be awaited first!");
13398 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
13399 return nativeResponseValue;
13401 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
13403 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
13404 if(!isWasmInitialized) {
13405 throw new Error("initializeWasm() must be awaited first!");
13407 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
13408 return nativeResponseValue;
13410 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
13412 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
13413 if(!isWasmInitialized) {
13414 throw new Error("initializeWasm() must be awaited first!");
13416 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
13417 // debug statements here
13419 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
13421 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
13422 if(!isWasmInitialized) {
13423 throw new Error("initializeWasm() must be awaited first!");
13425 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
13426 return nativeResponseValue;
13428 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
13430 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
13431 if(!isWasmInitialized) {
13432 throw new Error("initializeWasm() must be awaited first!");
13434 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
13435 return nativeResponseValue;
13437 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
13439 export function CResult_NonePeerHandleErrorZ_ok(): number {
13440 if(!isWasmInitialized) {
13441 throw new Error("initializeWasm() must be awaited first!");
13443 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
13444 return nativeResponseValue;
13446 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
13448 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
13449 if(!isWasmInitialized) {
13450 throw new Error("initializeWasm() must be awaited first!");
13452 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
13453 return nativeResponseValue;
13455 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
13457 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
13458 if(!isWasmInitialized) {
13459 throw new Error("initializeWasm() must be awaited first!");
13461 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
13462 return nativeResponseValue;
13464 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
13466 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
13467 if(!isWasmInitialized) {
13468 throw new Error("initializeWasm() must be awaited first!");
13470 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
13471 // debug statements here
13473 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
13475 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
13476 if(!isWasmInitialized) {
13477 throw new Error("initializeWasm() must be awaited first!");
13479 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
13480 return nativeResponseValue;
13482 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
13484 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
13485 if(!isWasmInitialized) {
13486 throw new Error("initializeWasm() must be awaited first!");
13488 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
13489 return nativeResponseValue;
13491 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
13493 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
13494 if(!isWasmInitialized) {
13495 throw new Error("initializeWasm() must be awaited first!");
13497 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
13498 return nativeResponseValue;
13500 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13502 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
13503 if(!isWasmInitialized) {
13504 throw new Error("initializeWasm() must be awaited first!");
13506 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
13507 return nativeResponseValue;
13509 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
13511 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
13512 if(!isWasmInitialized) {
13513 throw new Error("initializeWasm() must be awaited first!");
13515 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
13516 return nativeResponseValue;
13518 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
13520 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
13521 if(!isWasmInitialized) {
13522 throw new Error("initializeWasm() must be awaited first!");
13524 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
13525 // debug statements here
13527 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
13529 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
13530 if(!isWasmInitialized) {
13531 throw new Error("initializeWasm() must be awaited first!");
13533 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
13534 return nativeResponseValue;
13536 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
13538 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
13539 if(!isWasmInitialized) {
13540 throw new Error("initializeWasm() must be awaited first!");
13542 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
13543 return nativeResponseValue;
13545 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
13547 export function CResult_NoneErrorZ_ok(): number {
13548 if(!isWasmInitialized) {
13549 throw new Error("initializeWasm() must be awaited first!");
13551 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
13552 return nativeResponseValue;
13554 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
13556 export function CResult_NoneErrorZ_err(e: IOError): number {
13557 if(!isWasmInitialized) {
13558 throw new Error("initializeWasm() must be awaited first!");
13560 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
13561 return nativeResponseValue;
13563 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
13565 export function CResult_NoneErrorZ_is_ok(o: number): boolean {
13566 if(!isWasmInitialized) {
13567 throw new Error("initializeWasm() must be awaited first!");
13569 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13570 return nativeResponseValue;
13572 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13574 export function CResult_NoneErrorZ_free(_res: number): void {
13575 if(!isWasmInitialized) {
13576 throw new Error("initializeWasm() must be awaited first!");
13578 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13579 // debug statements here
13581 // uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13583 export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
13584 if(!isWasmInitialized) {
13585 throw new Error("initializeWasm() must be awaited first!");
13587 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13588 return nativeResponseValue;
13590 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13592 export function CResult_NoneErrorZ_clone(orig: number): number {
13593 if(!isWasmInitialized) {
13594 throw new Error("initializeWasm() must be awaited first!");
13596 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13597 return nativeResponseValue;
13599 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13601 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
13602 if(!isWasmInitialized) {
13603 throw new Error("initializeWasm() must be awaited first!");
13605 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13606 return nativeResponseValue;
13608 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13610 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
13611 if(!isWasmInitialized) {
13612 throw new Error("initializeWasm() must be awaited first!");
13614 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13615 return nativeResponseValue;
13617 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13619 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
13620 if(!isWasmInitialized) {
13621 throw new Error("initializeWasm() must be awaited first!");
13623 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13624 return nativeResponseValue;
13626 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13628 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
13629 if(!isWasmInitialized) {
13630 throw new Error("initializeWasm() must be awaited first!");
13632 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13633 // debug statements here
13635 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13637 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
13638 if(!isWasmInitialized) {
13639 throw new Error("initializeWasm() must be awaited first!");
13641 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13642 return nativeResponseValue;
13644 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13646 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
13647 if(!isWasmInitialized) {
13648 throw new Error("initializeWasm() must be awaited first!");
13650 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13651 return nativeResponseValue;
13653 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13655 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13656 if(!isWasmInitialized) {
13657 throw new Error("initializeWasm() must be awaited first!");
13659 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13660 // debug statements here
13662 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13664 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13665 if(!isWasmInitialized) {
13666 throw new Error("initializeWasm() must be awaited first!");
13668 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13669 // debug statements here
13671 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13673 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13674 if(!isWasmInitialized) {
13675 throw new Error("initializeWasm() must be awaited first!");
13677 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13678 // debug statements here
13680 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13682 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13683 if(!isWasmInitialized) {
13684 throw new Error("initializeWasm() must be awaited first!");
13686 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13687 // debug statements here
13689 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13691 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
13692 if(!isWasmInitialized) {
13693 throw new Error("initializeWasm() must be awaited first!");
13695 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13696 return nativeResponseValue;
13698 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13700 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
13701 if(!isWasmInitialized) {
13702 throw new Error("initializeWasm() must be awaited first!");
13704 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13705 return nativeResponseValue;
13707 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13709 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
13710 if(!isWasmInitialized) {
13711 throw new Error("initializeWasm() must be awaited first!");
13713 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13714 return nativeResponseValue;
13716 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13718 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
13719 if(!isWasmInitialized) {
13720 throw new Error("initializeWasm() must be awaited first!");
13722 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13723 // debug statements here
13725 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13727 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
13728 if(!isWasmInitialized) {
13729 throw new Error("initializeWasm() must be awaited first!");
13731 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13732 return nativeResponseValue;
13734 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13736 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
13737 if(!isWasmInitialized) {
13738 throw new Error("initializeWasm() must be awaited first!");
13740 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13741 return nativeResponseValue;
13743 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13745 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
13746 if(!isWasmInitialized) {
13747 throw new Error("initializeWasm() must be awaited first!");
13749 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13750 return nativeResponseValue;
13752 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13754 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
13755 if(!isWasmInitialized) {
13756 throw new Error("initializeWasm() must be awaited first!");
13758 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13759 return nativeResponseValue;
13761 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13763 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
13764 if(!isWasmInitialized) {
13765 throw new Error("initializeWasm() must be awaited first!");
13767 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13768 return nativeResponseValue;
13770 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13772 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
13773 if(!isWasmInitialized) {
13774 throw new Error("initializeWasm() must be awaited first!");
13776 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13777 // debug statements here
13779 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13781 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
13782 if(!isWasmInitialized) {
13783 throw new Error("initializeWasm() must be awaited first!");
13785 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13786 return nativeResponseValue;
13788 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13790 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
13791 if(!isWasmInitialized) {
13792 throw new Error("initializeWasm() must be awaited first!");
13794 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13795 return nativeResponseValue;
13797 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13799 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
13800 if(!isWasmInitialized) {
13801 throw new Error("initializeWasm() must be awaited first!");
13803 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13804 return nativeResponseValue;
13806 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13808 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
13809 if(!isWasmInitialized) {
13810 throw new Error("initializeWasm() must be awaited first!");
13812 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13813 return nativeResponseValue;
13815 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13817 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
13818 if(!isWasmInitialized) {
13819 throw new Error("initializeWasm() must be awaited first!");
13821 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13822 return nativeResponseValue;
13824 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13826 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
13827 if(!isWasmInitialized) {
13828 throw new Error("initializeWasm() must be awaited first!");
13830 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13831 // debug statements here
13833 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13835 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
13836 if(!isWasmInitialized) {
13837 throw new Error("initializeWasm() must be awaited first!");
13839 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13840 return nativeResponseValue;
13842 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13844 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
13845 if(!isWasmInitialized) {
13846 throw new Error("initializeWasm() must be awaited first!");
13848 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13849 return nativeResponseValue;
13851 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13853 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
13854 if(!isWasmInitialized) {
13855 throw new Error("initializeWasm() must be awaited first!");
13857 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13858 return nativeResponseValue;
13860 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13862 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
13863 if(!isWasmInitialized) {
13864 throw new Error("initializeWasm() must be awaited first!");
13866 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13867 return nativeResponseValue;
13869 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13871 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
13872 if(!isWasmInitialized) {
13873 throw new Error("initializeWasm() must be awaited first!");
13875 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13876 return nativeResponseValue;
13878 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13880 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
13881 if(!isWasmInitialized) {
13882 throw new Error("initializeWasm() must be awaited first!");
13884 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13885 // debug statements here
13887 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13889 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13890 if(!isWasmInitialized) {
13891 throw new Error("initializeWasm() must be awaited first!");
13893 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13894 return nativeResponseValue;
13896 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13898 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
13899 if(!isWasmInitialized) {
13900 throw new Error("initializeWasm() must be awaited first!");
13902 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13903 return nativeResponseValue;
13905 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13907 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13908 if(!isWasmInitialized) {
13909 throw new Error("initializeWasm() must be awaited first!");
13911 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13912 return nativeResponseValue;
13914 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13916 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13917 if(!isWasmInitialized) {
13918 throw new Error("initializeWasm() must be awaited first!");
13920 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13921 return nativeResponseValue;
13923 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13925 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13926 if(!isWasmInitialized) {
13927 throw new Error("initializeWasm() must be awaited first!");
13929 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13930 return nativeResponseValue;
13932 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13934 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13935 if(!isWasmInitialized) {
13936 throw new Error("initializeWasm() must be awaited first!");
13938 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13939 // debug statements here
13941 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13943 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13944 if(!isWasmInitialized) {
13945 throw new Error("initializeWasm() must be awaited first!");
13947 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13948 return nativeResponseValue;
13950 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13952 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13953 if(!isWasmInitialized) {
13954 throw new Error("initializeWasm() must be awaited first!");
13956 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13957 return nativeResponseValue;
13959 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13961 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13962 if(!isWasmInitialized) {
13963 throw new Error("initializeWasm() must be awaited first!");
13965 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13966 return nativeResponseValue;
13968 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13970 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13971 if(!isWasmInitialized) {
13972 throw new Error("initializeWasm() must be awaited first!");
13974 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13975 return nativeResponseValue;
13977 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13979 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13980 if(!isWasmInitialized) {
13981 throw new Error("initializeWasm() must be awaited first!");
13983 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13984 return nativeResponseValue;
13986 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13988 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13989 if(!isWasmInitialized) {
13990 throw new Error("initializeWasm() must be awaited first!");
13992 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13993 // debug statements here
13995 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13997 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13998 if(!isWasmInitialized) {
13999 throw new Error("initializeWasm() must be awaited first!");
14001 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
14002 return nativeResponseValue;
14004 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
14006 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
14007 if(!isWasmInitialized) {
14008 throw new Error("initializeWasm() must be awaited first!");
14010 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
14011 return nativeResponseValue;
14013 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
14015 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
14016 if(!isWasmInitialized) {
14017 throw new Error("initializeWasm() must be awaited first!");
14019 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
14020 return nativeResponseValue;
14022 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
14024 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
14025 if(!isWasmInitialized) {
14026 throw new Error("initializeWasm() must be awaited first!");
14028 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
14029 return nativeResponseValue;
14031 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
14033 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
14034 if(!isWasmInitialized) {
14035 throw new Error("initializeWasm() must be awaited first!");
14037 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
14038 return nativeResponseValue;
14040 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
14042 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
14043 if(!isWasmInitialized) {
14044 throw new Error("initializeWasm() must be awaited first!");
14046 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
14047 // debug statements here
14049 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
14051 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
14052 if(!isWasmInitialized) {
14053 throw new Error("initializeWasm() must be awaited first!");
14055 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
14056 return nativeResponseValue;
14058 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
14060 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
14061 if(!isWasmInitialized) {
14062 throw new Error("initializeWasm() must be awaited first!");
14064 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
14065 return nativeResponseValue;
14067 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
14069 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
14070 if(!isWasmInitialized) {
14071 throw new Error("initializeWasm() must be awaited first!");
14073 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
14074 return nativeResponseValue;
14076 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
14078 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
14079 if(!isWasmInitialized) {
14080 throw new Error("initializeWasm() must be awaited first!");
14082 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
14083 return nativeResponseValue;
14085 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
14087 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
14088 if(!isWasmInitialized) {
14089 throw new Error("initializeWasm() must be awaited first!");
14091 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
14092 return nativeResponseValue;
14094 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
14096 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
14097 if(!isWasmInitialized) {
14098 throw new Error("initializeWasm() must be awaited first!");
14100 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
14101 // debug statements here
14103 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
14105 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
14106 if(!isWasmInitialized) {
14107 throw new Error("initializeWasm() must be awaited first!");
14109 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
14110 return nativeResponseValue;
14112 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
14114 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
14115 if(!isWasmInitialized) {
14116 throw new Error("initializeWasm() must be awaited first!");
14118 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
14119 return nativeResponseValue;
14121 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
14123 export function CResult_ChannelReadyDecodeErrorZ_ok(o: number): number {
14124 if(!isWasmInitialized) {
14125 throw new Error("initializeWasm() must be awaited first!");
14127 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
14128 return nativeResponseValue;
14130 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
14132 export function CResult_ChannelReadyDecodeErrorZ_err(e: number): number {
14133 if(!isWasmInitialized) {
14134 throw new Error("initializeWasm() must be awaited first!");
14136 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
14137 return nativeResponseValue;
14139 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
14141 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: number): boolean {
14142 if(!isWasmInitialized) {
14143 throw new Error("initializeWasm() must be awaited first!");
14145 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
14146 return nativeResponseValue;
14148 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
14150 export function CResult_ChannelReadyDecodeErrorZ_free(_res: number): void {
14151 if(!isWasmInitialized) {
14152 throw new Error("initializeWasm() must be awaited first!");
14154 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
14155 // debug statements here
14157 // uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
14159 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: number): number {
14160 if(!isWasmInitialized) {
14161 throw new Error("initializeWasm() must be awaited first!");
14163 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
14164 return nativeResponseValue;
14166 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
14168 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: number): number {
14169 if(!isWasmInitialized) {
14170 throw new Error("initializeWasm() must be awaited first!");
14172 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
14173 return nativeResponseValue;
14175 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
14177 export function CResult_InitDecodeErrorZ_ok(o: number): number {
14178 if(!isWasmInitialized) {
14179 throw new Error("initializeWasm() must be awaited first!");
14181 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
14182 return nativeResponseValue;
14184 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
14186 export function CResult_InitDecodeErrorZ_err(e: number): number {
14187 if(!isWasmInitialized) {
14188 throw new Error("initializeWasm() must be awaited first!");
14190 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
14191 return nativeResponseValue;
14193 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
14195 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
14196 if(!isWasmInitialized) {
14197 throw new Error("initializeWasm() must be awaited first!");
14199 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
14200 return nativeResponseValue;
14202 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
14204 export function CResult_InitDecodeErrorZ_free(_res: number): void {
14205 if(!isWasmInitialized) {
14206 throw new Error("initializeWasm() must be awaited first!");
14208 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
14209 // debug statements here
14211 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
14213 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
14214 if(!isWasmInitialized) {
14215 throw new Error("initializeWasm() must be awaited first!");
14217 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
14218 return nativeResponseValue;
14220 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
14222 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
14223 if(!isWasmInitialized) {
14224 throw new Error("initializeWasm() must be awaited first!");
14226 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
14227 return nativeResponseValue;
14229 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
14231 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
14232 if(!isWasmInitialized) {
14233 throw new Error("initializeWasm() must be awaited first!");
14235 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
14236 return nativeResponseValue;
14238 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
14240 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
14241 if(!isWasmInitialized) {
14242 throw new Error("initializeWasm() must be awaited first!");
14244 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
14245 return nativeResponseValue;
14247 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
14249 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
14250 if(!isWasmInitialized) {
14251 throw new Error("initializeWasm() must be awaited first!");
14253 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
14254 return nativeResponseValue;
14256 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
14258 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
14259 if(!isWasmInitialized) {
14260 throw new Error("initializeWasm() must be awaited first!");
14262 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
14263 // debug statements here
14265 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
14267 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
14268 if(!isWasmInitialized) {
14269 throw new Error("initializeWasm() must be awaited first!");
14271 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
14272 return nativeResponseValue;
14274 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
14276 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
14277 if(!isWasmInitialized) {
14278 throw new Error("initializeWasm() must be awaited first!");
14280 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
14281 return nativeResponseValue;
14283 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
14285 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
14286 if(!isWasmInitialized) {
14287 throw new Error("initializeWasm() must be awaited first!");
14289 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
14290 return nativeResponseValue;
14292 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
14294 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
14295 if(!isWasmInitialized) {
14296 throw new Error("initializeWasm() must be awaited first!");
14298 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
14299 return nativeResponseValue;
14301 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
14303 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
14304 if(!isWasmInitialized) {
14305 throw new Error("initializeWasm() must be awaited first!");
14307 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
14308 return nativeResponseValue;
14310 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
14312 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
14313 if(!isWasmInitialized) {
14314 throw new Error("initializeWasm() must be awaited first!");
14316 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
14317 // debug statements here
14319 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
14321 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
14322 if(!isWasmInitialized) {
14323 throw new Error("initializeWasm() must be awaited first!");
14325 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
14326 return nativeResponseValue;
14328 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
14330 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
14331 if(!isWasmInitialized) {
14332 throw new Error("initializeWasm() must be awaited first!");
14334 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
14335 return nativeResponseValue;
14337 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
14339 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
14340 if(!isWasmInitialized) {
14341 throw new Error("initializeWasm() must be awaited first!");
14343 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
14344 return nativeResponseValue;
14346 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
14348 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
14349 if(!isWasmInitialized) {
14350 throw new Error("initializeWasm() must be awaited first!");
14352 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
14353 return nativeResponseValue;
14355 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
14357 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
14358 if(!isWasmInitialized) {
14359 throw new Error("initializeWasm() must be awaited first!");
14361 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
14362 return nativeResponseValue;
14364 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
14366 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
14367 if(!isWasmInitialized) {
14368 throw new Error("initializeWasm() must be awaited first!");
14370 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
14371 // debug statements here
14373 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
14375 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
14376 if(!isWasmInitialized) {
14377 throw new Error("initializeWasm() must be awaited first!");
14379 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
14380 return nativeResponseValue;
14382 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
14384 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
14385 if(!isWasmInitialized) {
14386 throw new Error("initializeWasm() must be awaited first!");
14388 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
14389 return nativeResponseValue;
14391 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
14393 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
14394 if(!isWasmInitialized) {
14395 throw new Error("initializeWasm() must be awaited first!");
14397 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
14398 return nativeResponseValue;
14400 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14402 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
14403 if(!isWasmInitialized) {
14404 throw new Error("initializeWasm() must be awaited first!");
14406 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
14407 return nativeResponseValue;
14409 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
14411 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
14412 if(!isWasmInitialized) {
14413 throw new Error("initializeWasm() must be awaited first!");
14415 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
14416 return nativeResponseValue;
14418 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
14420 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
14421 if(!isWasmInitialized) {
14422 throw new Error("initializeWasm() must be awaited first!");
14424 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
14425 // debug statements here
14427 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
14429 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14430 if(!isWasmInitialized) {
14431 throw new Error("initializeWasm() must be awaited first!");
14433 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
14434 return nativeResponseValue;
14436 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
14438 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
14439 if(!isWasmInitialized) {
14440 throw new Error("initializeWasm() must be awaited first!");
14442 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
14443 return nativeResponseValue;
14445 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
14447 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
14448 if(!isWasmInitialized) {
14449 throw new Error("initializeWasm() must be awaited first!");
14451 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
14452 return nativeResponseValue;
14454 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14456 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
14457 if(!isWasmInitialized) {
14458 throw new Error("initializeWasm() must be awaited first!");
14460 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
14461 return nativeResponseValue;
14463 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
14465 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
14466 if(!isWasmInitialized) {
14467 throw new Error("initializeWasm() must be awaited first!");
14469 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
14470 return nativeResponseValue;
14472 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
14474 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
14475 if(!isWasmInitialized) {
14476 throw new Error("initializeWasm() must be awaited first!");
14478 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
14479 // debug statements here
14481 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
14483 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14484 if(!isWasmInitialized) {
14485 throw new Error("initializeWasm() must be awaited first!");
14487 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
14488 return nativeResponseValue;
14490 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
14492 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
14493 if(!isWasmInitialized) {
14494 throw new Error("initializeWasm() must be awaited first!");
14496 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
14497 return nativeResponseValue;
14499 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
14501 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
14502 if(!isWasmInitialized) {
14503 throw new Error("initializeWasm() must be awaited first!");
14505 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
14506 return nativeResponseValue;
14508 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
14510 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
14511 if(!isWasmInitialized) {
14512 throw new Error("initializeWasm() must be awaited first!");
14514 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
14515 return nativeResponseValue;
14517 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
14519 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
14520 if(!isWasmInitialized) {
14521 throw new Error("initializeWasm() must be awaited first!");
14523 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
14524 return nativeResponseValue;
14526 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
14528 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
14529 if(!isWasmInitialized) {
14530 throw new Error("initializeWasm() must be awaited first!");
14532 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
14533 // debug statements here
14535 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
14537 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
14538 if(!isWasmInitialized) {
14539 throw new Error("initializeWasm() must be awaited first!");
14541 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
14542 return nativeResponseValue;
14544 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
14546 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
14547 if(!isWasmInitialized) {
14548 throw new Error("initializeWasm() must be awaited first!");
14550 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
14551 return nativeResponseValue;
14553 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
14555 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
14556 if(!isWasmInitialized) {
14557 throw new Error("initializeWasm() must be awaited first!");
14559 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
14560 return nativeResponseValue;
14562 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14564 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
14565 if(!isWasmInitialized) {
14566 throw new Error("initializeWasm() must be awaited first!");
14568 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14569 return nativeResponseValue;
14571 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14573 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
14574 if(!isWasmInitialized) {
14575 throw new Error("initializeWasm() must be awaited first!");
14577 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14578 return nativeResponseValue;
14580 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14582 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
14583 if(!isWasmInitialized) {
14584 throw new Error("initializeWasm() must be awaited first!");
14586 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14587 // debug statements here
14589 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14591 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14592 if(!isWasmInitialized) {
14593 throw new Error("initializeWasm() must be awaited first!");
14595 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14596 return nativeResponseValue;
14598 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14600 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
14601 if(!isWasmInitialized) {
14602 throw new Error("initializeWasm() must be awaited first!");
14604 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14605 return nativeResponseValue;
14607 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14609 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
14610 if(!isWasmInitialized) {
14611 throw new Error("initializeWasm() must be awaited first!");
14613 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14614 return nativeResponseValue;
14616 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14618 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
14619 if(!isWasmInitialized) {
14620 throw new Error("initializeWasm() must be awaited first!");
14622 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14623 return nativeResponseValue;
14625 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14627 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
14628 if(!isWasmInitialized) {
14629 throw new Error("initializeWasm() must be awaited first!");
14631 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14632 return nativeResponseValue;
14634 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14636 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
14637 if(!isWasmInitialized) {
14638 throw new Error("initializeWasm() must be awaited first!");
14640 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14641 // debug statements here
14643 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14645 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14646 if(!isWasmInitialized) {
14647 throw new Error("initializeWasm() must be awaited first!");
14649 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14650 return nativeResponseValue;
14652 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14654 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
14655 if(!isWasmInitialized) {
14656 throw new Error("initializeWasm() must be awaited first!");
14658 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14659 return nativeResponseValue;
14661 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14663 export function CResult_PingDecodeErrorZ_ok(o: number): number {
14664 if(!isWasmInitialized) {
14665 throw new Error("initializeWasm() must be awaited first!");
14667 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14668 return nativeResponseValue;
14670 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14672 export function CResult_PingDecodeErrorZ_err(e: number): number {
14673 if(!isWasmInitialized) {
14674 throw new Error("initializeWasm() must be awaited first!");
14676 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14677 return nativeResponseValue;
14679 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14681 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
14682 if(!isWasmInitialized) {
14683 throw new Error("initializeWasm() must be awaited first!");
14685 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14686 return nativeResponseValue;
14688 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14690 export function CResult_PingDecodeErrorZ_free(_res: number): void {
14691 if(!isWasmInitialized) {
14692 throw new Error("initializeWasm() must be awaited first!");
14694 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14695 // debug statements here
14697 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14699 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
14700 if(!isWasmInitialized) {
14701 throw new Error("initializeWasm() must be awaited first!");
14703 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14704 return nativeResponseValue;
14706 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14708 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
14709 if(!isWasmInitialized) {
14710 throw new Error("initializeWasm() must be awaited first!");
14712 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14713 return nativeResponseValue;
14715 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14717 export function CResult_PongDecodeErrorZ_ok(o: number): number {
14718 if(!isWasmInitialized) {
14719 throw new Error("initializeWasm() must be awaited first!");
14721 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14722 return nativeResponseValue;
14724 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14726 export function CResult_PongDecodeErrorZ_err(e: number): number {
14727 if(!isWasmInitialized) {
14728 throw new Error("initializeWasm() must be awaited first!");
14730 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14731 return nativeResponseValue;
14733 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14735 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
14736 if(!isWasmInitialized) {
14737 throw new Error("initializeWasm() must be awaited first!");
14739 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14740 return nativeResponseValue;
14742 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14744 export function CResult_PongDecodeErrorZ_free(_res: number): void {
14745 if(!isWasmInitialized) {
14746 throw new Error("initializeWasm() must be awaited first!");
14748 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14749 // debug statements here
14751 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14753 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
14754 if(!isWasmInitialized) {
14755 throw new Error("initializeWasm() must be awaited first!");
14757 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14758 return nativeResponseValue;
14760 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14762 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
14763 if(!isWasmInitialized) {
14764 throw new Error("initializeWasm() must be awaited first!");
14766 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14767 return nativeResponseValue;
14769 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14771 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14772 if(!isWasmInitialized) {
14773 throw new Error("initializeWasm() must be awaited first!");
14775 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14776 return nativeResponseValue;
14778 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14780 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
14781 if(!isWasmInitialized) {
14782 throw new Error("initializeWasm() must be awaited first!");
14784 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14785 return nativeResponseValue;
14787 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14789 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14790 if(!isWasmInitialized) {
14791 throw new Error("initializeWasm() must be awaited first!");
14793 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14794 return nativeResponseValue;
14796 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14798 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14799 if(!isWasmInitialized) {
14800 throw new Error("initializeWasm() must be awaited first!");
14802 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14803 // debug statements here
14805 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14807 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14808 if(!isWasmInitialized) {
14809 throw new Error("initializeWasm() must be awaited first!");
14811 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14812 return nativeResponseValue;
14814 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14816 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14817 if(!isWasmInitialized) {
14818 throw new Error("initializeWasm() must be awaited first!");
14820 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14821 return nativeResponseValue;
14823 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14825 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14826 if(!isWasmInitialized) {
14827 throw new Error("initializeWasm() must be awaited first!");
14829 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14830 return nativeResponseValue;
14832 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14834 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
14835 if(!isWasmInitialized) {
14836 throw new Error("initializeWasm() must be awaited first!");
14838 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14839 return nativeResponseValue;
14841 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14843 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14844 if(!isWasmInitialized) {
14845 throw new Error("initializeWasm() must be awaited first!");
14847 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14848 return nativeResponseValue;
14850 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14852 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14853 if(!isWasmInitialized) {
14854 throw new Error("initializeWasm() must be awaited first!");
14856 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14857 // debug statements here
14859 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14861 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14862 if(!isWasmInitialized) {
14863 throw new Error("initializeWasm() must be awaited first!");
14865 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14866 return nativeResponseValue;
14868 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14870 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14871 if(!isWasmInitialized) {
14872 throw new Error("initializeWasm() must be awaited first!");
14874 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14875 return nativeResponseValue;
14877 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14879 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
14880 if(!isWasmInitialized) {
14881 throw new Error("initializeWasm() must be awaited first!");
14883 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14884 return nativeResponseValue;
14886 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14888 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
14889 if(!isWasmInitialized) {
14890 throw new Error("initializeWasm() must be awaited first!");
14892 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14893 return nativeResponseValue;
14895 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14897 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14898 if(!isWasmInitialized) {
14899 throw new Error("initializeWasm() must be awaited first!");
14901 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14902 return nativeResponseValue;
14904 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14906 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14907 if(!isWasmInitialized) {
14908 throw new Error("initializeWasm() must be awaited first!");
14910 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14911 // debug statements here
14913 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14915 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14916 if(!isWasmInitialized) {
14917 throw new Error("initializeWasm() must be awaited first!");
14919 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14920 return nativeResponseValue;
14922 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14924 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14925 if(!isWasmInitialized) {
14926 throw new Error("initializeWasm() must be awaited first!");
14928 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14929 return nativeResponseValue;
14931 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14933 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14934 if(!isWasmInitialized) {
14935 throw new Error("initializeWasm() must be awaited first!");
14937 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14938 return nativeResponseValue;
14940 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14942 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14943 if(!isWasmInitialized) {
14944 throw new Error("initializeWasm() must be awaited first!");
14946 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14947 return nativeResponseValue;
14949 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14951 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14952 if(!isWasmInitialized) {
14953 throw new Error("initializeWasm() must be awaited first!");
14955 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14956 return nativeResponseValue;
14958 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14960 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14961 if(!isWasmInitialized) {
14962 throw new Error("initializeWasm() must be awaited first!");
14964 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14965 // debug statements here
14967 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14969 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14970 if(!isWasmInitialized) {
14971 throw new Error("initializeWasm() must be awaited first!");
14973 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14974 return nativeResponseValue;
14976 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14978 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14979 if(!isWasmInitialized) {
14980 throw new Error("initializeWasm() must be awaited first!");
14982 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14983 return nativeResponseValue;
14985 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14987 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14988 if(!isWasmInitialized) {
14989 throw new Error("initializeWasm() must be awaited first!");
14991 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14992 return nativeResponseValue;
14994 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14996 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14997 if(!isWasmInitialized) {
14998 throw new Error("initializeWasm() must be awaited first!");
15000 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
15001 return nativeResponseValue;
15003 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
15005 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
15006 if(!isWasmInitialized) {
15007 throw new Error("initializeWasm() must be awaited first!");
15009 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
15010 return nativeResponseValue;
15012 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
15014 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
15015 if(!isWasmInitialized) {
15016 throw new Error("initializeWasm() must be awaited first!");
15018 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
15019 // debug statements here
15021 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
15023 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
15024 if(!isWasmInitialized) {
15025 throw new Error("initializeWasm() must be awaited first!");
15027 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
15028 return nativeResponseValue;
15030 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
15032 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
15033 if(!isWasmInitialized) {
15034 throw new Error("initializeWasm() must be awaited first!");
15036 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
15037 return nativeResponseValue;
15039 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
15041 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
15042 if(!isWasmInitialized) {
15043 throw new Error("initializeWasm() must be awaited first!");
15045 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
15046 return nativeResponseValue;
15048 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
15050 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
15051 if(!isWasmInitialized) {
15052 throw new Error("initializeWasm() must be awaited first!");
15054 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
15055 return nativeResponseValue;
15057 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
15059 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
15060 if(!isWasmInitialized) {
15061 throw new Error("initializeWasm() must be awaited first!");
15063 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
15064 return nativeResponseValue;
15066 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
15068 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
15069 if(!isWasmInitialized) {
15070 throw new Error("initializeWasm() must be awaited first!");
15072 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
15073 // debug statements here
15075 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
15077 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
15078 if(!isWasmInitialized) {
15079 throw new Error("initializeWasm() must be awaited first!");
15081 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
15082 return nativeResponseValue;
15084 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
15086 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
15087 if(!isWasmInitialized) {
15088 throw new Error("initializeWasm() must be awaited first!");
15090 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
15091 return nativeResponseValue;
15093 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
15095 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
15096 if(!isWasmInitialized) {
15097 throw new Error("initializeWasm() must be awaited first!");
15099 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
15100 return nativeResponseValue;
15102 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15104 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
15105 if(!isWasmInitialized) {
15106 throw new Error("initializeWasm() must be awaited first!");
15108 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
15109 return nativeResponseValue;
15111 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15113 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
15114 if(!isWasmInitialized) {
15115 throw new Error("initializeWasm() must be awaited first!");
15117 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
15118 return nativeResponseValue;
15120 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
15122 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
15123 if(!isWasmInitialized) {
15124 throw new Error("initializeWasm() must be awaited first!");
15126 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
15127 // debug statements here
15129 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15131 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
15132 if(!isWasmInitialized) {
15133 throw new Error("initializeWasm() must be awaited first!");
15135 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
15136 return nativeResponseValue;
15138 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15140 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
15141 if(!isWasmInitialized) {
15142 throw new Error("initializeWasm() must be awaited first!");
15144 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
15145 return nativeResponseValue;
15147 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
15149 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
15150 if(!isWasmInitialized) {
15151 throw new Error("initializeWasm() must be awaited first!");
15153 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
15154 return nativeResponseValue;
15156 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15158 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
15159 if(!isWasmInitialized) {
15160 throw new Error("initializeWasm() must be awaited first!");
15162 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
15163 return nativeResponseValue;
15165 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15167 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
15168 if(!isWasmInitialized) {
15169 throw new Error("initializeWasm() must be awaited first!");
15171 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
15172 return nativeResponseValue;
15174 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
15176 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
15177 if(!isWasmInitialized) {
15178 throw new Error("initializeWasm() must be awaited first!");
15180 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
15181 // debug statements here
15183 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15185 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
15186 if(!isWasmInitialized) {
15187 throw new Error("initializeWasm() must be awaited first!");
15189 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
15190 return nativeResponseValue;
15192 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15194 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
15195 if(!isWasmInitialized) {
15196 throw new Error("initializeWasm() must be awaited first!");
15198 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
15199 return nativeResponseValue;
15201 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
15203 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
15204 if(!isWasmInitialized) {
15205 throw new Error("initializeWasm() must be awaited first!");
15207 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
15208 return nativeResponseValue;
15210 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
15212 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
15213 if(!isWasmInitialized) {
15214 throw new Error("initializeWasm() must be awaited first!");
15216 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
15217 return nativeResponseValue;
15219 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
15221 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
15222 if(!isWasmInitialized) {
15223 throw new Error("initializeWasm() must be awaited first!");
15225 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
15226 return nativeResponseValue;
15228 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
15230 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
15231 if(!isWasmInitialized) {
15232 throw new Error("initializeWasm() must be awaited first!");
15234 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
15235 // debug statements here
15237 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
15239 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
15240 if(!isWasmInitialized) {
15241 throw new Error("initializeWasm() must be awaited first!");
15243 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
15244 return nativeResponseValue;
15246 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
15248 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
15249 if(!isWasmInitialized) {
15250 throw new Error("initializeWasm() must be awaited first!");
15252 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
15253 return nativeResponseValue;
15255 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
15257 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
15258 if(!isWasmInitialized) {
15259 throw new Error("initializeWasm() must be awaited first!");
15261 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
15262 return nativeResponseValue;
15264 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
15266 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
15267 if(!isWasmInitialized) {
15268 throw new Error("initializeWasm() must be awaited first!");
15270 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
15271 return nativeResponseValue;
15273 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
15275 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
15276 if(!isWasmInitialized) {
15277 throw new Error("initializeWasm() must be awaited first!");
15279 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
15280 return nativeResponseValue;
15282 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
15284 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
15285 if(!isWasmInitialized) {
15286 throw new Error("initializeWasm() must be awaited first!");
15288 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
15289 // debug statements here
15291 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
15293 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
15294 if(!isWasmInitialized) {
15295 throw new Error("initializeWasm() must be awaited first!");
15297 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
15298 return nativeResponseValue;
15300 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
15302 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
15303 if(!isWasmInitialized) {
15304 throw new Error("initializeWasm() must be awaited first!");
15306 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
15307 return nativeResponseValue;
15309 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
15311 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
15312 if(!isWasmInitialized) {
15313 throw new Error("initializeWasm() must be awaited first!");
15315 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
15316 return nativeResponseValue;
15318 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15320 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
15321 if(!isWasmInitialized) {
15322 throw new Error("initializeWasm() must be awaited first!");
15324 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
15325 return nativeResponseValue;
15327 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
15329 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15330 if(!isWasmInitialized) {
15331 throw new Error("initializeWasm() must be awaited first!");
15333 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
15334 return nativeResponseValue;
15336 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
15338 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
15339 if(!isWasmInitialized) {
15340 throw new Error("initializeWasm() must be awaited first!");
15342 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
15343 // debug statements here
15345 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15347 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15348 if(!isWasmInitialized) {
15349 throw new Error("initializeWasm() must be awaited first!");
15351 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
15352 return nativeResponseValue;
15354 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15356 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
15357 if(!isWasmInitialized) {
15358 throw new Error("initializeWasm() must be awaited first!");
15360 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
15361 return nativeResponseValue;
15363 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
15365 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
15366 if(!isWasmInitialized) {
15367 throw new Error("initializeWasm() must be awaited first!");
15369 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
15370 return nativeResponseValue;
15372 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15374 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
15375 if(!isWasmInitialized) {
15376 throw new Error("initializeWasm() must be awaited first!");
15378 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
15379 return nativeResponseValue;
15381 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
15383 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15384 if(!isWasmInitialized) {
15385 throw new Error("initializeWasm() must be awaited first!");
15387 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
15388 return nativeResponseValue;
15390 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
15392 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
15393 if(!isWasmInitialized) {
15394 throw new Error("initializeWasm() must be awaited first!");
15396 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
15397 // debug statements here
15399 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15401 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15402 if(!isWasmInitialized) {
15403 throw new Error("initializeWasm() must be awaited first!");
15405 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
15406 return nativeResponseValue;
15408 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15410 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
15411 if(!isWasmInitialized) {
15412 throw new Error("initializeWasm() must be awaited first!");
15414 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
15415 return nativeResponseValue;
15417 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
15419 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
15420 if(!isWasmInitialized) {
15421 throw new Error("initializeWasm() must be awaited first!");
15423 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
15424 return nativeResponseValue;
15426 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
15428 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
15429 if(!isWasmInitialized) {
15430 throw new Error("initializeWasm() must be awaited first!");
15432 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
15433 return nativeResponseValue;
15435 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
15437 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
15438 if(!isWasmInitialized) {
15439 throw new Error("initializeWasm() must be awaited first!");
15441 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
15442 return nativeResponseValue;
15444 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
15446 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
15447 if(!isWasmInitialized) {
15448 throw new Error("initializeWasm() must be awaited first!");
15450 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
15451 // debug statements here
15453 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
15455 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
15456 if(!isWasmInitialized) {
15457 throw new Error("initializeWasm() must be awaited first!");
15459 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
15460 return nativeResponseValue;
15462 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
15464 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
15465 if(!isWasmInitialized) {
15466 throw new Error("initializeWasm() must be awaited first!");
15468 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
15469 return nativeResponseValue;
15471 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
15473 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
15474 if(!isWasmInitialized) {
15475 throw new Error("initializeWasm() must be awaited first!");
15477 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
15478 return nativeResponseValue;
15480 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
15482 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
15483 if(!isWasmInitialized) {
15484 throw new Error("initializeWasm() must be awaited first!");
15486 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
15487 return nativeResponseValue;
15489 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
15491 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
15492 if(!isWasmInitialized) {
15493 throw new Error("initializeWasm() must be awaited first!");
15495 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
15496 return nativeResponseValue;
15498 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
15500 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
15501 if(!isWasmInitialized) {
15502 throw new Error("initializeWasm() must be awaited first!");
15504 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
15505 // debug statements here
15507 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
15509 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
15510 if(!isWasmInitialized) {
15511 throw new Error("initializeWasm() must be awaited first!");
15513 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
15514 return nativeResponseValue;
15516 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
15518 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
15519 if(!isWasmInitialized) {
15520 throw new Error("initializeWasm() must be awaited first!");
15522 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
15523 return nativeResponseValue;
15525 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
15527 export function COption_FilterZ_some(o: number): number {
15528 if(!isWasmInitialized) {
15529 throw new Error("initializeWasm() must be awaited first!");
15531 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
15532 return nativeResponseValue;
15534 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
15536 export function COption_FilterZ_none(): number {
15537 if(!isWasmInitialized) {
15538 throw new Error("initializeWasm() must be awaited first!");
15540 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
15541 return nativeResponseValue;
15543 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
15545 export function COption_FilterZ_free(_res: number): void {
15546 if(!isWasmInitialized) {
15547 throw new Error("initializeWasm() must be awaited first!");
15549 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
15550 // debug statements here
15552 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
15554 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
15555 if(!isWasmInitialized) {
15556 throw new Error("initializeWasm() must be awaited first!");
15558 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
15559 return nativeResponseValue;
15561 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
15563 export function CResult_LockedChannelMonitorNoneZ_err(): number {
15564 if(!isWasmInitialized) {
15565 throw new Error("initializeWasm() must be awaited first!");
15567 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15568 return nativeResponseValue;
15570 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15572 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
15573 if(!isWasmInitialized) {
15574 throw new Error("initializeWasm() must be awaited first!");
15576 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15577 return nativeResponseValue;
15579 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15581 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
15582 if(!isWasmInitialized) {
15583 throw new Error("initializeWasm() must be awaited first!");
15585 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15586 // debug statements here
15588 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15590 export function CVec_OutPointZ_free(_res: number): void {
15591 if(!isWasmInitialized) {
15592 throw new Error("initializeWasm() must be awaited first!");
15594 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15595 // debug statements here
15597 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15599 export function PaymentPurpose_free(this_ptr: number): void {
15600 if(!isWasmInitialized) {
15601 throw new Error("initializeWasm() must be awaited first!");
15603 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15604 // debug statements here
15606 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15608 export function PaymentPurpose_clone_ptr(arg: number): number {
15609 if(!isWasmInitialized) {
15610 throw new Error("initializeWasm() must be awaited first!");
15612 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15613 return nativeResponseValue;
15615 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15617 export function PaymentPurpose_clone(orig: number): number {
15618 if(!isWasmInitialized) {
15619 throw new Error("initializeWasm() must be awaited first!");
15621 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15622 return nativeResponseValue;
15624 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15626 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
15627 if(!isWasmInitialized) {
15628 throw new Error("initializeWasm() must be awaited first!");
15630 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15631 return nativeResponseValue;
15633 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15635 export function PaymentPurpose_spontaneous_payment(a: number): number {
15636 if(!isWasmInitialized) {
15637 throw new Error("initializeWasm() must be awaited first!");
15639 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15640 return nativeResponseValue;
15642 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15644 export function PaymentPurpose_write(obj: number): number {
15645 if(!isWasmInitialized) {
15646 throw new Error("initializeWasm() must be awaited first!");
15648 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15649 return nativeResponseValue;
15651 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15653 export function PaymentPurpose_read(ser: number): number {
15654 if(!isWasmInitialized) {
15655 throw new Error("initializeWasm() must be awaited first!");
15657 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15658 return nativeResponseValue;
15660 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15662 export function ClosureReason_free(this_ptr: number): void {
15663 if(!isWasmInitialized) {
15664 throw new Error("initializeWasm() must be awaited first!");
15666 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15667 // debug statements here
15669 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15671 export function ClosureReason_clone_ptr(arg: number): number {
15672 if(!isWasmInitialized) {
15673 throw new Error("initializeWasm() must be awaited first!");
15675 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15676 return nativeResponseValue;
15678 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15680 export function ClosureReason_clone(orig: number): number {
15681 if(!isWasmInitialized) {
15682 throw new Error("initializeWasm() must be awaited first!");
15684 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15685 return nativeResponseValue;
15687 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15689 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
15690 if(!isWasmInitialized) {
15691 throw new Error("initializeWasm() must be awaited first!");
15693 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15694 return nativeResponseValue;
15696 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15698 export function ClosureReason_holder_force_closed(): number {
15699 if(!isWasmInitialized) {
15700 throw new Error("initializeWasm() must be awaited first!");
15702 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15703 return nativeResponseValue;
15705 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15707 export function ClosureReason_cooperative_closure(): number {
15708 if(!isWasmInitialized) {
15709 throw new Error("initializeWasm() must be awaited first!");
15711 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15712 return nativeResponseValue;
15714 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15716 export function ClosureReason_commitment_tx_confirmed(): number {
15717 if(!isWasmInitialized) {
15718 throw new Error("initializeWasm() must be awaited first!");
15720 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15721 return nativeResponseValue;
15723 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15725 export function ClosureReason_funding_timed_out(): number {
15726 if(!isWasmInitialized) {
15727 throw new Error("initializeWasm() must be awaited first!");
15729 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15730 return nativeResponseValue;
15732 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15734 export function ClosureReason_processing_error(err: number): number {
15735 if(!isWasmInitialized) {
15736 throw new Error("initializeWasm() must be awaited first!");
15738 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15739 return nativeResponseValue;
15741 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15743 export function ClosureReason_disconnected_peer(): number {
15744 if(!isWasmInitialized) {
15745 throw new Error("initializeWasm() must be awaited first!");
15747 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15748 return nativeResponseValue;
15750 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15752 export function ClosureReason_outdated_channel_manager(): number {
15753 if(!isWasmInitialized) {
15754 throw new Error("initializeWasm() must be awaited first!");
15756 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15757 return nativeResponseValue;
15759 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15761 export function ClosureReason_write(obj: number): number {
15762 if(!isWasmInitialized) {
15763 throw new Error("initializeWasm() must be awaited first!");
15765 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15766 return nativeResponseValue;
15768 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15770 export function ClosureReason_read(ser: number): number {
15771 if(!isWasmInitialized) {
15772 throw new Error("initializeWasm() must be awaited first!");
15774 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15775 return nativeResponseValue;
15777 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
15779 export function HTLCDestination_free(this_ptr: number): void {
15780 if(!isWasmInitialized) {
15781 throw new Error("initializeWasm() must be awaited first!");
15783 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
15784 // debug statements here
15786 // uintptr_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
15788 export function HTLCDestination_clone_ptr(arg: number): number {
15789 if(!isWasmInitialized) {
15790 throw new Error("initializeWasm() must be awaited first!");
15792 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
15793 return nativeResponseValue;
15795 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
15797 export function HTLCDestination_clone(orig: number): number {
15798 if(!isWasmInitialized) {
15799 throw new Error("initializeWasm() must be awaited first!");
15801 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
15802 return nativeResponseValue;
15804 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
15806 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): number {
15807 if(!isWasmInitialized) {
15808 throw new Error("initializeWasm() must be awaited first!");
15810 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
15811 return nativeResponseValue;
15813 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
15815 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): number {
15816 if(!isWasmInitialized) {
15817 throw new Error("initializeWasm() must be awaited first!");
15819 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
15820 return nativeResponseValue;
15822 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
15824 export function HTLCDestination_failed_payment(payment_hash: number): number {
15825 if(!isWasmInitialized) {
15826 throw new Error("initializeWasm() must be awaited first!");
15828 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
15829 return nativeResponseValue;
15831 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
15833 export function HTLCDestination_write(obj: number): number {
15834 if(!isWasmInitialized) {
15835 throw new Error("initializeWasm() must be awaited first!");
15837 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
15838 return nativeResponseValue;
15840 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
15842 export function HTLCDestination_read(ser: number): number {
15843 if(!isWasmInitialized) {
15844 throw new Error("initializeWasm() must be awaited first!");
15846 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
15847 return nativeResponseValue;
15849 // void Event_free(struct LDKEvent this_ptr);
15851 export function Event_free(this_ptr: number): void {
15852 if(!isWasmInitialized) {
15853 throw new Error("initializeWasm() must be awaited first!");
15855 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15856 // debug statements here
15858 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15860 export function Event_clone_ptr(arg: number): number {
15861 if(!isWasmInitialized) {
15862 throw new Error("initializeWasm() must be awaited first!");
15864 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15865 return nativeResponseValue;
15867 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15869 export function Event_clone(orig: number): number {
15870 if(!isWasmInitialized) {
15871 throw new Error("initializeWasm() must be awaited first!");
15873 const nativeResponseValue = wasm.TS_Event_clone(orig);
15874 return nativeResponseValue;
15876 // 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);
15878 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): number {
15879 if(!isWasmInitialized) {
15880 throw new Error("initializeWasm() must be awaited first!");
15882 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15883 return nativeResponseValue;
15885 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15887 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: number): number {
15888 if(!isWasmInitialized) {
15889 throw new Error("initializeWasm() must be awaited first!");
15891 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15892 return nativeResponseValue;
15894 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15896 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: number): number {
15897 if(!isWasmInitialized) {
15898 throw new Error("initializeWasm() must be awaited first!");
15900 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15901 return nativeResponseValue;
15903 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15905 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
15906 if(!isWasmInitialized) {
15907 throw new Error("initializeWasm() must be awaited first!");
15909 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15910 return nativeResponseValue;
15912 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15914 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
15915 if(!isWasmInitialized) {
15916 throw new Error("initializeWasm() must be awaited first!");
15918 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15919 return nativeResponseValue;
15921 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15923 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
15924 if(!isWasmInitialized) {
15925 throw new Error("initializeWasm() must be awaited first!");
15927 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15928 return nativeResponseValue;
15930 // 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);
15932 export function Event_payment_path_failed(payment_id: number, payment_hash: number, rejected_by_dest: boolean, network_update: number, all_paths_failed: boolean, path: number, short_channel_id: number, retry: number): number {
15933 if(!isWasmInitialized) {
15934 throw new Error("initializeWasm() must be awaited first!");
15936 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);
15937 return nativeResponseValue;
15939 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15941 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): number {
15942 if(!isWasmInitialized) {
15943 throw new Error("initializeWasm() must be awaited first!");
15945 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
15946 return nativeResponseValue;
15948 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
15950 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: number): number {
15951 if(!isWasmInitialized) {
15952 throw new Error("initializeWasm() must be awaited first!");
15954 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
15955 return nativeResponseValue;
15957 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15959 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
15960 if(!isWasmInitialized) {
15961 throw new Error("initializeWasm() must be awaited first!");
15963 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15964 return nativeResponseValue;
15966 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15968 export function Event_spendable_outputs(outputs: number): number {
15969 if(!isWasmInitialized) {
15970 throw new Error("initializeWasm() must be awaited first!");
15972 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15973 return nativeResponseValue;
15975 // 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);
15977 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
15978 if(!isWasmInitialized) {
15979 throw new Error("initializeWasm() must be awaited first!");
15981 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15982 return nativeResponseValue;
15984 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15986 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
15987 if(!isWasmInitialized) {
15988 throw new Error("initializeWasm() must be awaited first!");
15990 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15991 return nativeResponseValue;
15993 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
15995 export function Event_discard_funding(channel_id: number, transaction: number): number {
15996 if(!isWasmInitialized) {
15997 throw new Error("initializeWasm() must be awaited first!");
15999 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
16000 return nativeResponseValue;
16002 // 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);
16004 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
16005 if(!isWasmInitialized) {
16006 throw new Error("initializeWasm() must be awaited first!");
16008 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
16009 return nativeResponseValue;
16011 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
16013 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: number): number {
16014 if(!isWasmInitialized) {
16015 throw new Error("initializeWasm() must be awaited first!");
16017 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
16018 return nativeResponseValue;
16020 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
16022 export function Event_write(obj: number): number {
16023 if(!isWasmInitialized) {
16024 throw new Error("initializeWasm() must be awaited first!");
16026 const nativeResponseValue = wasm.TS_Event_write(obj);
16027 return nativeResponseValue;
16029 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
16031 export function Event_read(ser: number): number {
16032 if(!isWasmInitialized) {
16033 throw new Error("initializeWasm() must be awaited first!");
16035 const nativeResponseValue = wasm.TS_Event_read(ser);
16036 return nativeResponseValue;
16038 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
16040 export function MessageSendEvent_free(this_ptr: number): void {
16041 if(!isWasmInitialized) {
16042 throw new Error("initializeWasm() must be awaited first!");
16044 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
16045 // debug statements here
16047 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
16049 export function MessageSendEvent_clone_ptr(arg: number): number {
16050 if(!isWasmInitialized) {
16051 throw new Error("initializeWasm() must be awaited first!");
16053 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
16054 return nativeResponseValue;
16056 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
16058 export function MessageSendEvent_clone(orig: number): number {
16059 if(!isWasmInitialized) {
16060 throw new Error("initializeWasm() must be awaited first!");
16062 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
16063 return nativeResponseValue;
16065 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
16067 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
16068 if(!isWasmInitialized) {
16069 throw new Error("initializeWasm() must be awaited first!");
16071 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
16072 return nativeResponseValue;
16074 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
16076 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
16077 if(!isWasmInitialized) {
16078 throw new Error("initializeWasm() must be awaited first!");
16080 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
16081 return nativeResponseValue;
16083 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
16085 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
16086 if(!isWasmInitialized) {
16087 throw new Error("initializeWasm() must be awaited first!");
16089 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
16090 return nativeResponseValue;
16092 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
16094 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
16095 if(!isWasmInitialized) {
16096 throw new Error("initializeWasm() must be awaited first!");
16098 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
16099 return nativeResponseValue;
16101 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
16103 export function MessageSendEvent_send_channel_ready(node_id: number, msg: number): number {
16104 if(!isWasmInitialized) {
16105 throw new Error("initializeWasm() must be awaited first!");
16107 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
16108 return nativeResponseValue;
16110 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
16112 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
16113 if(!isWasmInitialized) {
16114 throw new Error("initializeWasm() must be awaited first!");
16116 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
16117 return nativeResponseValue;
16119 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
16121 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
16122 if(!isWasmInitialized) {
16123 throw new Error("initializeWasm() must be awaited first!");
16125 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
16126 return nativeResponseValue;
16128 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
16130 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
16131 if(!isWasmInitialized) {
16132 throw new Error("initializeWasm() must be awaited first!");
16134 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
16135 return nativeResponseValue;
16137 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
16139 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
16140 if(!isWasmInitialized) {
16141 throw new Error("initializeWasm() must be awaited first!");
16143 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
16144 return nativeResponseValue;
16146 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
16148 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
16149 if(!isWasmInitialized) {
16150 throw new Error("initializeWasm() must be awaited first!");
16152 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
16153 return nativeResponseValue;
16155 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
16157 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
16158 if(!isWasmInitialized) {
16159 throw new Error("initializeWasm() must be awaited first!");
16161 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
16162 return nativeResponseValue;
16164 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
16166 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
16167 if(!isWasmInitialized) {
16168 throw new Error("initializeWasm() must be awaited first!");
16170 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
16171 return nativeResponseValue;
16173 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
16175 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
16176 if(!isWasmInitialized) {
16177 throw new Error("initializeWasm() must be awaited first!");
16179 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
16180 return nativeResponseValue;
16182 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
16184 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
16185 if(!isWasmInitialized) {
16186 throw new Error("initializeWasm() must be awaited first!");
16188 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
16189 return nativeResponseValue;
16191 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
16193 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
16194 if(!isWasmInitialized) {
16195 throw new Error("initializeWasm() must be awaited first!");
16197 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
16198 return nativeResponseValue;
16200 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
16202 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
16203 if(!isWasmInitialized) {
16204 throw new Error("initializeWasm() must be awaited first!");
16206 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
16207 return nativeResponseValue;
16209 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
16211 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
16212 if(!isWasmInitialized) {
16213 throw new Error("initializeWasm() must be awaited first!");
16215 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
16216 return nativeResponseValue;
16218 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
16220 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
16221 if(!isWasmInitialized) {
16222 throw new Error("initializeWasm() must be awaited first!");
16224 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
16225 return nativeResponseValue;
16227 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
16229 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
16230 if(!isWasmInitialized) {
16231 throw new Error("initializeWasm() must be awaited first!");
16233 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
16234 return nativeResponseValue;
16236 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
16238 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
16239 if(!isWasmInitialized) {
16240 throw new Error("initializeWasm() must be awaited first!");
16242 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
16243 return nativeResponseValue;
16245 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
16247 export function MessageSendEventsProvider_free(this_ptr: number): void {
16248 if(!isWasmInitialized) {
16249 throw new Error("initializeWasm() must be awaited first!");
16251 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
16252 // debug statements here
16254 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
16256 export function EventsProvider_free(this_ptr: number): void {
16257 if(!isWasmInitialized) {
16258 throw new Error("initializeWasm() must be awaited first!");
16260 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
16261 // debug statements here
16263 // void EventHandler_free(struct LDKEventHandler this_ptr);
16265 export function EventHandler_free(this_ptr: number): void {
16266 if(!isWasmInitialized) {
16267 throw new Error("initializeWasm() must be awaited first!");
16269 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
16270 // debug statements here
16272 // void APIError_free(struct LDKAPIError this_ptr);
16274 export function APIError_free(this_ptr: number): void {
16275 if(!isWasmInitialized) {
16276 throw new Error("initializeWasm() must be awaited first!");
16278 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
16279 // debug statements here
16281 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
16283 export function APIError_clone_ptr(arg: number): number {
16284 if(!isWasmInitialized) {
16285 throw new Error("initializeWasm() must be awaited first!");
16287 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
16288 return nativeResponseValue;
16290 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
16292 export function APIError_clone(orig: number): number {
16293 if(!isWasmInitialized) {
16294 throw new Error("initializeWasm() must be awaited first!");
16296 const nativeResponseValue = wasm.TS_APIError_clone(orig);
16297 return nativeResponseValue;
16299 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
16301 export function APIError_apimisuse_error(err: number): number {
16302 if(!isWasmInitialized) {
16303 throw new Error("initializeWasm() must be awaited first!");
16305 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
16306 return nativeResponseValue;
16308 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
16310 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
16311 if(!isWasmInitialized) {
16312 throw new Error("initializeWasm() must be awaited first!");
16314 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
16315 return nativeResponseValue;
16317 // struct LDKAPIError APIError_route_error(struct LDKStr err);
16319 export function APIError_route_error(err: number): number {
16320 if(!isWasmInitialized) {
16321 throw new Error("initializeWasm() must be awaited first!");
16323 const nativeResponseValue = wasm.TS_APIError_route_error(err);
16324 return nativeResponseValue;
16326 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
16328 export function APIError_channel_unavailable(err: number): number {
16329 if(!isWasmInitialized) {
16330 throw new Error("initializeWasm() must be awaited first!");
16332 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
16333 return nativeResponseValue;
16335 // struct LDKAPIError APIError_monitor_update_failed(void);
16337 export function APIError_monitor_update_failed(): number {
16338 if(!isWasmInitialized) {
16339 throw new Error("initializeWasm() must be awaited first!");
16341 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
16342 return nativeResponseValue;
16344 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
16346 export function APIError_incompatible_shutdown_script(script: number): number {
16347 if(!isWasmInitialized) {
16348 throw new Error("initializeWasm() must be awaited first!");
16350 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
16351 return nativeResponseValue;
16353 // void BigSize_free(struct LDKBigSize this_obj);
16355 export function BigSize_free(this_obj: number): void {
16356 if(!isWasmInitialized) {
16357 throw new Error("initializeWasm() must be awaited first!");
16359 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
16360 // debug statements here
16362 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
16364 export function BigSize_get_a(this_ptr: number): bigint {
16365 if(!isWasmInitialized) {
16366 throw new Error("initializeWasm() must be awaited first!");
16368 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
16369 return nativeResponseValue;
16371 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
16373 export function BigSize_set_a(this_ptr: number, val: bigint): void {
16374 if(!isWasmInitialized) {
16375 throw new Error("initializeWasm() must be awaited first!");
16377 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
16378 // debug statements here
16380 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
16382 export function BigSize_new(a_arg: bigint): number {
16383 if(!isWasmInitialized) {
16384 throw new Error("initializeWasm() must be awaited first!");
16386 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
16387 return nativeResponseValue;
16389 // void Hostname_free(struct LDKHostname this_obj);
16391 export function Hostname_free(this_obj: number): void {
16392 if(!isWasmInitialized) {
16393 throw new Error("initializeWasm() must be awaited first!");
16395 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
16396 // debug statements here
16398 // uintptr_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
16400 export function Hostname_clone_ptr(arg: number): number {
16401 if(!isWasmInitialized) {
16402 throw new Error("initializeWasm() must be awaited first!");
16404 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
16405 return nativeResponseValue;
16407 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
16409 export function Hostname_clone(orig: number): number {
16410 if(!isWasmInitialized) {
16411 throw new Error("initializeWasm() must be awaited first!");
16413 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
16414 return nativeResponseValue;
16416 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
16418 export function Hostname_len(this_arg: number): number {
16419 if(!isWasmInitialized) {
16420 throw new Error("initializeWasm() must be awaited first!");
16422 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
16423 return nativeResponseValue;
16425 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
16427 export function sign(msg: number, sk: number): number {
16428 if(!isWasmInitialized) {
16429 throw new Error("initializeWasm() must be awaited first!");
16431 const nativeResponseValue = wasm.TS_sign(msg, sk);
16432 return nativeResponseValue;
16434 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
16436 export function recover_pk(msg: number, sig: number): number {
16437 if(!isWasmInitialized) {
16438 throw new Error("initializeWasm() must be awaited first!");
16440 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
16441 return nativeResponseValue;
16443 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
16445 export function verify(msg: number, sig: number, pk: number): boolean {
16446 if(!isWasmInitialized) {
16447 throw new Error("initializeWasm() must be awaited first!");
16449 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
16450 return nativeResponseValue;
16452 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
16454 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
16455 if(!isWasmInitialized) {
16456 throw new Error("initializeWasm() must be awaited first!");
16458 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
16459 return nativeResponseValue;
16461 // void Persister_free(struct LDKPersister this_ptr);
16463 export function Persister_free(this_ptr: number): void {
16464 if(!isWasmInitialized) {
16465 throw new Error("initializeWasm() must be awaited first!");
16467 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
16468 // debug statements here
16470 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
16472 export function Level_clone(orig: number): Level {
16473 if(!isWasmInitialized) {
16474 throw new Error("initializeWasm() must be awaited first!");
16476 const nativeResponseValue = wasm.TS_Level_clone(orig);
16477 return nativeResponseValue;
16479 // enum LDKLevel Level_gossip(void);
16481 export function Level_gossip(): Level {
16482 if(!isWasmInitialized) {
16483 throw new Error("initializeWasm() must be awaited first!");
16485 const nativeResponseValue = wasm.TS_Level_gossip();
16486 return nativeResponseValue;
16488 // enum LDKLevel Level_trace(void);
16490 export function Level_trace(): Level {
16491 if(!isWasmInitialized) {
16492 throw new Error("initializeWasm() must be awaited first!");
16494 const nativeResponseValue = wasm.TS_Level_trace();
16495 return nativeResponseValue;
16497 // enum LDKLevel Level_debug(void);
16499 export function Level_debug(): Level {
16500 if(!isWasmInitialized) {
16501 throw new Error("initializeWasm() must be awaited first!");
16503 const nativeResponseValue = wasm.TS_Level_debug();
16504 return nativeResponseValue;
16506 // enum LDKLevel Level_info(void);
16508 export function Level_info(): Level {
16509 if(!isWasmInitialized) {
16510 throw new Error("initializeWasm() must be awaited first!");
16512 const nativeResponseValue = wasm.TS_Level_info();
16513 return nativeResponseValue;
16515 // enum LDKLevel Level_warn(void);
16517 export function Level_warn(): Level {
16518 if(!isWasmInitialized) {
16519 throw new Error("initializeWasm() must be awaited first!");
16521 const nativeResponseValue = wasm.TS_Level_warn();
16522 return nativeResponseValue;
16524 // enum LDKLevel Level_error(void);
16526 export function Level_error(): Level {
16527 if(!isWasmInitialized) {
16528 throw new Error("initializeWasm() must be awaited first!");
16530 const nativeResponseValue = wasm.TS_Level_error();
16531 return nativeResponseValue;
16533 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
16535 export function Level_eq(a: number, b: number): boolean {
16536 if(!isWasmInitialized) {
16537 throw new Error("initializeWasm() must be awaited first!");
16539 const nativeResponseValue = wasm.TS_Level_eq(a, b);
16540 return nativeResponseValue;
16542 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
16544 export function Level_hash(o: number): bigint {
16545 if(!isWasmInitialized) {
16546 throw new Error("initializeWasm() must be awaited first!");
16548 const nativeResponseValue = wasm.TS_Level_hash(o);
16549 return nativeResponseValue;
16551 // MUST_USE_RES enum LDKLevel Level_max(void);
16553 export function Level_max(): Level {
16554 if(!isWasmInitialized) {
16555 throw new Error("initializeWasm() must be awaited first!");
16557 const nativeResponseValue = wasm.TS_Level_max();
16558 return nativeResponseValue;
16560 // void Record_free(struct LDKRecord this_obj);
16562 export function Record_free(this_obj: number): void {
16563 if(!isWasmInitialized) {
16564 throw new Error("initializeWasm() must be awaited first!");
16566 const nativeResponseValue = wasm.TS_Record_free(this_obj);
16567 // debug statements here
16569 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
16571 export function Record_get_level(this_ptr: number): Level {
16572 if(!isWasmInitialized) {
16573 throw new Error("initializeWasm() must be awaited first!");
16575 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
16576 return nativeResponseValue;
16578 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
16580 export function Record_set_level(this_ptr: number, val: Level): void {
16581 if(!isWasmInitialized) {
16582 throw new Error("initializeWasm() must be awaited first!");
16584 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
16585 // debug statements here
16587 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
16589 export function Record_get_args(this_ptr: number): number {
16590 if(!isWasmInitialized) {
16591 throw new Error("initializeWasm() must be awaited first!");
16593 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
16594 return nativeResponseValue;
16596 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16598 export function Record_set_args(this_ptr: number, val: number): void {
16599 if(!isWasmInitialized) {
16600 throw new Error("initializeWasm() must be awaited first!");
16602 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
16603 // debug statements here
16605 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
16607 export function Record_get_module_path(this_ptr: number): number {
16608 if(!isWasmInitialized) {
16609 throw new Error("initializeWasm() must be awaited first!");
16611 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
16612 return nativeResponseValue;
16614 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16616 export function Record_set_module_path(this_ptr: number, val: number): void {
16617 if(!isWasmInitialized) {
16618 throw new Error("initializeWasm() must be awaited first!");
16620 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
16621 // debug statements here
16623 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
16625 export function Record_get_file(this_ptr: number): number {
16626 if(!isWasmInitialized) {
16627 throw new Error("initializeWasm() must be awaited first!");
16629 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
16630 return nativeResponseValue;
16632 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16634 export function Record_set_file(this_ptr: number, val: number): void {
16635 if(!isWasmInitialized) {
16636 throw new Error("initializeWasm() must be awaited first!");
16638 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
16639 // debug statements here
16641 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
16643 export function Record_get_line(this_ptr: number): number {
16644 if(!isWasmInitialized) {
16645 throw new Error("initializeWasm() must be awaited first!");
16647 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
16648 return nativeResponseValue;
16650 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
16652 export function Record_set_line(this_ptr: number, val: number): void {
16653 if(!isWasmInitialized) {
16654 throw new Error("initializeWasm() must be awaited first!");
16656 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
16657 // debug statements here
16659 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
16661 export function Record_clone_ptr(arg: number): number {
16662 if(!isWasmInitialized) {
16663 throw new Error("initializeWasm() must be awaited first!");
16665 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
16666 return nativeResponseValue;
16668 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
16670 export function Record_clone(orig: number): number {
16671 if(!isWasmInitialized) {
16672 throw new Error("initializeWasm() must be awaited first!");
16674 const nativeResponseValue = wasm.TS_Record_clone(orig);
16675 return nativeResponseValue;
16677 // void Logger_free(struct LDKLogger this_ptr);
16679 export function Logger_free(this_ptr: number): void {
16680 if(!isWasmInitialized) {
16681 throw new Error("initializeWasm() must be awaited first!");
16683 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
16684 // debug statements here
16686 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
16688 export function ChannelHandshakeConfig_free(this_obj: number): void {
16689 if(!isWasmInitialized) {
16690 throw new Error("initializeWasm() must be awaited first!");
16692 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
16693 // debug statements here
16695 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16697 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
16698 if(!isWasmInitialized) {
16699 throw new Error("initializeWasm() must be awaited first!");
16701 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16702 return nativeResponseValue;
16704 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16706 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
16707 if(!isWasmInitialized) {
16708 throw new Error("initializeWasm() must be awaited first!");
16710 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16711 // debug statements here
16713 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16715 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
16716 if(!isWasmInitialized) {
16717 throw new Error("initializeWasm() must be awaited first!");
16719 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16720 return nativeResponseValue;
16722 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16724 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
16725 if(!isWasmInitialized) {
16726 throw new Error("initializeWasm() must be awaited first!");
16728 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16729 // debug statements here
16731 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16733 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
16734 if(!isWasmInitialized) {
16735 throw new Error("initializeWasm() must be awaited first!");
16737 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16738 return nativeResponseValue;
16740 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16742 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16743 if(!isWasmInitialized) {
16744 throw new Error("initializeWasm() must be awaited first!");
16746 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16747 // debug statements here
16749 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16751 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number): number {
16752 if(!isWasmInitialized) {
16753 throw new Error("initializeWasm() must be awaited first!");
16755 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16756 return nativeResponseValue;
16758 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16760 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number, val: number): void {
16761 if(!isWasmInitialized) {
16762 throw new Error("initializeWasm() must be awaited first!");
16764 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16765 // debug statements here
16767 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16769 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
16770 if(!isWasmInitialized) {
16771 throw new Error("initializeWasm() must be awaited first!");
16773 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16774 return nativeResponseValue;
16776 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16778 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
16779 if(!isWasmInitialized) {
16780 throw new Error("initializeWasm() must be awaited first!");
16782 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16783 // debug statements here
16785 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16787 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: number): boolean {
16788 if(!isWasmInitialized) {
16789 throw new Error("initializeWasm() must be awaited first!");
16791 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
16792 return nativeResponseValue;
16794 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16796 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: number, val: boolean): void {
16797 if(!isWasmInitialized) {
16798 throw new Error("initializeWasm() must be awaited first!");
16800 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
16801 // debug statements here
16803 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16805 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
16806 if(!isWasmInitialized) {
16807 throw new Error("initializeWasm() must be awaited first!");
16809 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16810 return nativeResponseValue;
16812 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16814 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
16815 if(!isWasmInitialized) {
16816 throw new Error("initializeWasm() must be awaited first!");
16818 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16819 // debug statements here
16821 // 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);
16823 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): number {
16824 if(!isWasmInitialized) {
16825 throw new Error("initializeWasm() must be awaited first!");
16827 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);
16828 return nativeResponseValue;
16830 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16832 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
16833 if(!isWasmInitialized) {
16834 throw new Error("initializeWasm() must be awaited first!");
16836 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16837 return nativeResponseValue;
16839 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16841 export function ChannelHandshakeConfig_clone(orig: number): number {
16842 if(!isWasmInitialized) {
16843 throw new Error("initializeWasm() must be awaited first!");
16845 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16846 return nativeResponseValue;
16848 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16850 export function ChannelHandshakeConfig_default(): number {
16851 if(!isWasmInitialized) {
16852 throw new Error("initializeWasm() must be awaited first!");
16854 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16855 return nativeResponseValue;
16857 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16859 export function ChannelHandshakeLimits_free(this_obj: number): void {
16860 if(!isWasmInitialized) {
16861 throw new Error("initializeWasm() must be awaited first!");
16863 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16864 // debug statements here
16866 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16868 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
16869 if(!isWasmInitialized) {
16870 throw new Error("initializeWasm() must be awaited first!");
16872 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16873 return nativeResponseValue;
16875 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16877 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
16878 if(!isWasmInitialized) {
16879 throw new Error("initializeWasm() must be awaited first!");
16881 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16882 // debug statements here
16884 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16886 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: number): bigint {
16887 if(!isWasmInitialized) {
16888 throw new Error("initializeWasm() must be awaited first!");
16890 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16891 return nativeResponseValue;
16893 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16895 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: number, val: bigint): void {
16896 if(!isWasmInitialized) {
16897 throw new Error("initializeWasm() must be awaited first!");
16899 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16900 // debug statements here
16902 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16904 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
16905 if(!isWasmInitialized) {
16906 throw new Error("initializeWasm() must be awaited first!");
16908 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16909 return nativeResponseValue;
16911 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16913 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16914 if(!isWasmInitialized) {
16915 throw new Error("initializeWasm() must be awaited first!");
16917 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16918 // debug statements here
16920 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16922 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16923 if(!isWasmInitialized) {
16924 throw new Error("initializeWasm() must be awaited first!");
16926 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16927 return nativeResponseValue;
16929 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16931 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16932 if(!isWasmInitialized) {
16933 throw new Error("initializeWasm() must be awaited first!");
16935 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16936 // debug statements here
16938 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16940 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
16941 if(!isWasmInitialized) {
16942 throw new Error("initializeWasm() must be awaited first!");
16944 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16945 return nativeResponseValue;
16947 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16949 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16950 if(!isWasmInitialized) {
16951 throw new Error("initializeWasm() must be awaited first!");
16953 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16954 // debug statements here
16956 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16958 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
16959 if(!isWasmInitialized) {
16960 throw new Error("initializeWasm() must be awaited first!");
16962 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16963 return nativeResponseValue;
16965 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16967 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
16968 if(!isWasmInitialized) {
16969 throw new Error("initializeWasm() must be awaited first!");
16971 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16972 // debug statements here
16974 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16976 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
16977 if(!isWasmInitialized) {
16978 throw new Error("initializeWasm() must be awaited first!");
16980 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16981 return nativeResponseValue;
16983 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16985 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
16986 if(!isWasmInitialized) {
16987 throw new Error("initializeWasm() must be awaited first!");
16989 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16990 // debug statements here
16992 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16994 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: number): boolean {
16995 if(!isWasmInitialized) {
16996 throw new Error("initializeWasm() must be awaited first!");
16998 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
16999 return nativeResponseValue;
17001 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17003 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: number, val: boolean): void {
17004 if(!isWasmInitialized) {
17005 throw new Error("initializeWasm() must be awaited first!");
17007 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
17008 // debug statements here
17010 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17012 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
17013 if(!isWasmInitialized) {
17014 throw new Error("initializeWasm() must be awaited first!");
17016 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
17017 return nativeResponseValue;
17019 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17021 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
17022 if(!isWasmInitialized) {
17023 throw new Error("initializeWasm() must be awaited first!");
17025 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
17026 // debug statements here
17028 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17030 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
17031 if(!isWasmInitialized) {
17032 throw new Error("initializeWasm() must be awaited first!");
17034 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
17035 return nativeResponseValue;
17037 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
17039 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
17040 if(!isWasmInitialized) {
17041 throw new Error("initializeWasm() must be awaited first!");
17043 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
17044 // debug statements here
17046 // 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);
17048 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): number {
17049 if(!isWasmInitialized) {
17050 throw new Error("initializeWasm() must be awaited first!");
17052 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);
17053 return nativeResponseValue;
17055 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
17057 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
17058 if(!isWasmInitialized) {
17059 throw new Error("initializeWasm() must be awaited first!");
17061 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
17062 return nativeResponseValue;
17064 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
17066 export function ChannelHandshakeLimits_clone(orig: number): number {
17067 if(!isWasmInitialized) {
17068 throw new Error("initializeWasm() must be awaited first!");
17070 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
17071 return nativeResponseValue;
17073 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
17075 export function ChannelHandshakeLimits_default(): number {
17076 if(!isWasmInitialized) {
17077 throw new Error("initializeWasm() must be awaited first!");
17079 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
17080 return nativeResponseValue;
17082 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
17084 export function ChannelConfig_free(this_obj: number): void {
17085 if(!isWasmInitialized) {
17086 throw new Error("initializeWasm() must be awaited first!");
17088 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
17089 // debug statements here
17091 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17093 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
17094 if(!isWasmInitialized) {
17095 throw new Error("initializeWasm() must be awaited first!");
17097 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
17098 return nativeResponseValue;
17100 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
17102 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
17103 if(!isWasmInitialized) {
17104 throw new Error("initializeWasm() must be awaited first!");
17106 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
17107 // debug statements here
17109 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17111 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
17112 if(!isWasmInitialized) {
17113 throw new Error("initializeWasm() must be awaited first!");
17115 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
17116 return nativeResponseValue;
17118 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
17120 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
17121 if(!isWasmInitialized) {
17122 throw new Error("initializeWasm() must be awaited first!");
17124 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
17125 // debug statements here
17127 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17129 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
17130 if(!isWasmInitialized) {
17131 throw new Error("initializeWasm() must be awaited first!");
17133 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
17134 return nativeResponseValue;
17136 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
17138 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
17139 if(!isWasmInitialized) {
17140 throw new Error("initializeWasm() must be awaited first!");
17142 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
17143 // debug statements here
17145 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17147 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
17148 if(!isWasmInitialized) {
17149 throw new Error("initializeWasm() must be awaited first!");
17151 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
17152 return nativeResponseValue;
17154 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
17156 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
17157 if(!isWasmInitialized) {
17158 throw new Error("initializeWasm() must be awaited first!");
17160 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
17161 // debug statements here
17163 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17165 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
17166 if(!isWasmInitialized) {
17167 throw new Error("initializeWasm() must be awaited first!");
17169 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
17170 return nativeResponseValue;
17172 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
17174 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
17175 if(!isWasmInitialized) {
17176 throw new Error("initializeWasm() must be awaited first!");
17178 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
17179 // debug statements here
17181 // 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);
17183 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): number {
17184 if(!isWasmInitialized) {
17185 throw new Error("initializeWasm() must be awaited first!");
17187 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);
17188 return nativeResponseValue;
17190 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
17192 export function ChannelConfig_clone_ptr(arg: number): number {
17193 if(!isWasmInitialized) {
17194 throw new Error("initializeWasm() must be awaited first!");
17196 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
17197 return nativeResponseValue;
17199 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
17201 export function ChannelConfig_clone(orig: number): number {
17202 if(!isWasmInitialized) {
17203 throw new Error("initializeWasm() must be awaited first!");
17205 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
17206 return nativeResponseValue;
17208 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
17210 export function ChannelConfig_default(): number {
17211 if(!isWasmInitialized) {
17212 throw new Error("initializeWasm() must be awaited first!");
17214 const nativeResponseValue = wasm.TS_ChannelConfig_default();
17215 return nativeResponseValue;
17217 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
17219 export function ChannelConfig_write(obj: number): number {
17220 if(!isWasmInitialized) {
17221 throw new Error("initializeWasm() must be awaited first!");
17223 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
17224 return nativeResponseValue;
17226 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
17228 export function ChannelConfig_read(ser: number): number {
17229 if(!isWasmInitialized) {
17230 throw new Error("initializeWasm() must be awaited first!");
17232 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
17233 return nativeResponseValue;
17235 // void UserConfig_free(struct LDKUserConfig this_obj);
17237 export function UserConfig_free(this_obj: number): void {
17238 if(!isWasmInitialized) {
17239 throw new Error("initializeWasm() must be awaited first!");
17241 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
17242 // debug statements here
17244 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17246 export function UserConfig_get_channel_handshake_config(this_ptr: number): number {
17247 if(!isWasmInitialized) {
17248 throw new Error("initializeWasm() must be awaited first!");
17250 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
17251 return nativeResponseValue;
17253 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
17255 export function UserConfig_set_channel_handshake_config(this_ptr: number, val: number): void {
17256 if(!isWasmInitialized) {
17257 throw new Error("initializeWasm() must be awaited first!");
17259 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
17260 // debug statements here
17262 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17264 export function UserConfig_get_channel_handshake_limits(this_ptr: number): number {
17265 if(!isWasmInitialized) {
17266 throw new Error("initializeWasm() must be awaited first!");
17268 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
17269 return nativeResponseValue;
17271 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
17273 export function UserConfig_set_channel_handshake_limits(this_ptr: number, val: number): void {
17274 if(!isWasmInitialized) {
17275 throw new Error("initializeWasm() must be awaited first!");
17277 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
17278 // debug statements here
17280 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17282 export function UserConfig_get_channel_config(this_ptr: number): number {
17283 if(!isWasmInitialized) {
17284 throw new Error("initializeWasm() must be awaited first!");
17286 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
17287 return nativeResponseValue;
17289 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
17291 export function UserConfig_set_channel_config(this_ptr: number, val: number): void {
17292 if(!isWasmInitialized) {
17293 throw new Error("initializeWasm() must be awaited first!");
17295 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
17296 // debug statements here
17298 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17300 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
17301 if(!isWasmInitialized) {
17302 throw new Error("initializeWasm() must be awaited first!");
17304 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
17305 return nativeResponseValue;
17307 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17309 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
17310 if(!isWasmInitialized) {
17311 throw new Error("initializeWasm() must be awaited first!");
17313 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
17314 // debug statements here
17316 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17318 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
17319 if(!isWasmInitialized) {
17320 throw new Error("initializeWasm() must be awaited first!");
17322 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
17323 return nativeResponseValue;
17325 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17327 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
17328 if(!isWasmInitialized) {
17329 throw new Error("initializeWasm() must be awaited first!");
17331 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
17332 // debug statements here
17334 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17336 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
17337 if(!isWasmInitialized) {
17338 throw new Error("initializeWasm() must be awaited first!");
17340 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
17341 return nativeResponseValue;
17343 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17345 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
17346 if(!isWasmInitialized) {
17347 throw new Error("initializeWasm() must be awaited first!");
17349 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
17350 // debug statements here
17352 // 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);
17354 export function UserConfig_new(channel_handshake_config_arg: number, channel_handshake_limits_arg: number, channel_config_arg: number, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean, manually_accept_inbound_channels_arg: boolean): number {
17355 if(!isWasmInitialized) {
17356 throw new Error("initializeWasm() must be awaited first!");
17358 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);
17359 return nativeResponseValue;
17361 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
17363 export function UserConfig_clone_ptr(arg: number): number {
17364 if(!isWasmInitialized) {
17365 throw new Error("initializeWasm() must be awaited first!");
17367 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
17368 return nativeResponseValue;
17370 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
17372 export function UserConfig_clone(orig: number): number {
17373 if(!isWasmInitialized) {
17374 throw new Error("initializeWasm() must be awaited first!");
17376 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
17377 return nativeResponseValue;
17379 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
17381 export function UserConfig_default(): number {
17382 if(!isWasmInitialized) {
17383 throw new Error("initializeWasm() must be awaited first!");
17385 const nativeResponseValue = wasm.TS_UserConfig_default();
17386 return nativeResponseValue;
17388 // void BestBlock_free(struct LDKBestBlock this_obj);
17390 export function BestBlock_free(this_obj: number): void {
17391 if(!isWasmInitialized) {
17392 throw new Error("initializeWasm() must be awaited first!");
17394 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
17395 // debug statements here
17397 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
17399 export function BestBlock_clone_ptr(arg: number): number {
17400 if(!isWasmInitialized) {
17401 throw new Error("initializeWasm() must be awaited first!");
17403 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
17404 return nativeResponseValue;
17406 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
17408 export function BestBlock_clone(orig: number): number {
17409 if(!isWasmInitialized) {
17410 throw new Error("initializeWasm() must be awaited first!");
17412 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
17413 return nativeResponseValue;
17415 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
17417 export function BestBlock_from_genesis(network: Network): number {
17418 if(!isWasmInitialized) {
17419 throw new Error("initializeWasm() must be awaited first!");
17421 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
17422 return nativeResponseValue;
17424 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
17426 export function BestBlock_new(block_hash: number, height: number): number {
17427 if(!isWasmInitialized) {
17428 throw new Error("initializeWasm() must be awaited first!");
17430 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
17431 return nativeResponseValue;
17433 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
17435 export function BestBlock_block_hash(this_arg: number): number {
17436 if(!isWasmInitialized) {
17437 throw new Error("initializeWasm() must be awaited first!");
17439 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
17440 return nativeResponseValue;
17442 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
17444 export function BestBlock_height(this_arg: number): number {
17445 if(!isWasmInitialized) {
17446 throw new Error("initializeWasm() must be awaited first!");
17448 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
17449 return nativeResponseValue;
17451 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
17453 export function AccessError_clone(orig: number): AccessError {
17454 if(!isWasmInitialized) {
17455 throw new Error("initializeWasm() must be awaited first!");
17457 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
17458 return nativeResponseValue;
17460 // enum LDKAccessError AccessError_unknown_chain(void);
17462 export function AccessError_unknown_chain(): AccessError {
17463 if(!isWasmInitialized) {
17464 throw new Error("initializeWasm() must be awaited first!");
17466 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
17467 return nativeResponseValue;
17469 // enum LDKAccessError AccessError_unknown_tx(void);
17471 export function AccessError_unknown_tx(): AccessError {
17472 if(!isWasmInitialized) {
17473 throw new Error("initializeWasm() must be awaited first!");
17475 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
17476 return nativeResponseValue;
17478 // void Access_free(struct LDKAccess this_ptr);
17480 export function Access_free(this_ptr: number): void {
17481 if(!isWasmInitialized) {
17482 throw new Error("initializeWasm() must be awaited first!");
17484 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
17485 // debug statements here
17487 // void Listen_free(struct LDKListen this_ptr);
17489 export function Listen_free(this_ptr: number): void {
17490 if(!isWasmInitialized) {
17491 throw new Error("initializeWasm() must be awaited first!");
17493 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
17494 // debug statements here
17496 // void Confirm_free(struct LDKConfirm this_ptr);
17498 export function Confirm_free(this_ptr: number): void {
17499 if(!isWasmInitialized) {
17500 throw new Error("initializeWasm() must be awaited first!");
17502 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
17503 // debug statements here
17505 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
17507 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
17508 if(!isWasmInitialized) {
17509 throw new Error("initializeWasm() must be awaited first!");
17511 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
17512 return nativeResponseValue;
17514 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
17516 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
17517 if(!isWasmInitialized) {
17518 throw new Error("initializeWasm() must be awaited first!");
17520 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
17521 return nativeResponseValue;
17523 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
17525 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
17526 if(!isWasmInitialized) {
17527 throw new Error("initializeWasm() must be awaited first!");
17529 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
17530 return nativeResponseValue;
17532 // void Watch_free(struct LDKWatch this_ptr);
17534 export function Watch_free(this_ptr: number): void {
17535 if(!isWasmInitialized) {
17536 throw new Error("initializeWasm() must be awaited first!");
17538 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
17539 // debug statements here
17541 // void Filter_free(struct LDKFilter this_ptr);
17543 export function Filter_free(this_ptr: number): void {
17544 if(!isWasmInitialized) {
17545 throw new Error("initializeWasm() must be awaited first!");
17547 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
17548 // debug statements here
17550 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
17552 export function WatchedOutput_free(this_obj: number): void {
17553 if(!isWasmInitialized) {
17554 throw new Error("initializeWasm() must be awaited first!");
17556 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
17557 // debug statements here
17559 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17561 export function WatchedOutput_get_block_hash(this_ptr: number): number {
17562 if(!isWasmInitialized) {
17563 throw new Error("initializeWasm() must be awaited first!");
17565 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
17566 return nativeResponseValue;
17568 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17570 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
17571 if(!isWasmInitialized) {
17572 throw new Error("initializeWasm() must be awaited first!");
17574 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
17575 // debug statements here
17577 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17579 export function WatchedOutput_get_outpoint(this_ptr: number): number {
17580 if(!isWasmInitialized) {
17581 throw new Error("initializeWasm() must be awaited first!");
17583 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
17584 return nativeResponseValue;
17586 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17588 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
17589 if(!isWasmInitialized) {
17590 throw new Error("initializeWasm() must be awaited first!");
17592 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
17593 // debug statements here
17595 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17597 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
17598 if(!isWasmInitialized) {
17599 throw new Error("initializeWasm() must be awaited first!");
17601 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
17602 return nativeResponseValue;
17604 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17606 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
17607 if(!isWasmInitialized) {
17608 throw new Error("initializeWasm() must be awaited first!");
17610 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
17611 // debug statements here
17613 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
17615 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
17616 if(!isWasmInitialized) {
17617 throw new Error("initializeWasm() must be awaited first!");
17619 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
17620 return nativeResponseValue;
17622 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
17624 export function WatchedOutput_clone_ptr(arg: number): number {
17625 if(!isWasmInitialized) {
17626 throw new Error("initializeWasm() must be awaited first!");
17628 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
17629 return nativeResponseValue;
17631 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
17633 export function WatchedOutput_clone(orig: number): number {
17634 if(!isWasmInitialized) {
17635 throw new Error("initializeWasm() must be awaited first!");
17637 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
17638 return nativeResponseValue;
17640 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
17642 export function WatchedOutput_hash(o: number): bigint {
17643 if(!isWasmInitialized) {
17644 throw new Error("initializeWasm() must be awaited first!");
17646 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
17647 return nativeResponseValue;
17649 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
17651 export function BroadcasterInterface_free(this_ptr: number): void {
17652 if(!isWasmInitialized) {
17653 throw new Error("initializeWasm() must be awaited first!");
17655 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
17656 // debug statements here
17658 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
17660 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
17661 if(!isWasmInitialized) {
17662 throw new Error("initializeWasm() must be awaited first!");
17664 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
17665 return nativeResponseValue;
17667 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
17669 export function ConfirmationTarget_background(): ConfirmationTarget {
17670 if(!isWasmInitialized) {
17671 throw new Error("initializeWasm() must be awaited first!");
17673 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
17674 return nativeResponseValue;
17676 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
17678 export function ConfirmationTarget_normal(): ConfirmationTarget {
17679 if(!isWasmInitialized) {
17680 throw new Error("initializeWasm() must be awaited first!");
17682 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
17683 return nativeResponseValue;
17685 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
17687 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
17688 if(!isWasmInitialized) {
17689 throw new Error("initializeWasm() must be awaited first!");
17691 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
17692 return nativeResponseValue;
17694 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
17696 export function ConfirmationTarget_eq(a: number, b: number): boolean {
17697 if(!isWasmInitialized) {
17698 throw new Error("initializeWasm() must be awaited first!");
17700 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
17701 return nativeResponseValue;
17703 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17705 export function FeeEstimator_free(this_ptr: number): void {
17706 if(!isWasmInitialized) {
17707 throw new Error("initializeWasm() must be awaited first!");
17709 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17710 // debug statements here
17712 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17714 export function MonitorUpdateId_free(this_obj: number): void {
17715 if(!isWasmInitialized) {
17716 throw new Error("initializeWasm() must be awaited first!");
17718 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17719 // debug statements here
17721 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17723 export function MonitorUpdateId_clone_ptr(arg: number): number {
17724 if(!isWasmInitialized) {
17725 throw new Error("initializeWasm() must be awaited first!");
17727 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17728 return nativeResponseValue;
17730 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17732 export function MonitorUpdateId_clone(orig: number): number {
17733 if(!isWasmInitialized) {
17734 throw new Error("initializeWasm() must be awaited first!");
17736 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17737 return nativeResponseValue;
17739 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17741 export function MonitorUpdateId_hash(o: number): bigint {
17742 if(!isWasmInitialized) {
17743 throw new Error("initializeWasm() must be awaited first!");
17745 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17746 return nativeResponseValue;
17748 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17750 export function MonitorUpdateId_eq(a: number, b: number): boolean {
17751 if(!isWasmInitialized) {
17752 throw new Error("initializeWasm() must be awaited first!");
17754 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17755 return nativeResponseValue;
17757 // void Persist_free(struct LDKPersist this_ptr);
17759 export function Persist_free(this_ptr: number): void {
17760 if(!isWasmInitialized) {
17761 throw new Error("initializeWasm() must be awaited first!");
17763 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17764 // debug statements here
17766 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17768 export function LockedChannelMonitor_free(this_obj: number): void {
17769 if(!isWasmInitialized) {
17770 throw new Error("initializeWasm() must be awaited first!");
17772 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17773 // debug statements here
17775 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17777 export function ChainMonitor_free(this_obj: number): void {
17778 if(!isWasmInitialized) {
17779 throw new Error("initializeWasm() must be awaited first!");
17781 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17782 // debug statements here
17784 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17786 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
17787 if(!isWasmInitialized) {
17788 throw new Error("initializeWasm() must be awaited first!");
17790 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17791 return nativeResponseValue;
17793 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17795 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
17796 if(!isWasmInitialized) {
17797 throw new Error("initializeWasm() must be awaited first!");
17799 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17800 return nativeResponseValue;
17802 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17804 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
17805 if(!isWasmInitialized) {
17806 throw new Error("initializeWasm() must be awaited first!");
17808 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17809 return nativeResponseValue;
17811 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17813 export function ChainMonitor_list_monitors(this_arg: number): number {
17814 if(!isWasmInitialized) {
17815 throw new Error("initializeWasm() must be awaited first!");
17817 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17818 return nativeResponseValue;
17820 // 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);
17822 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
17823 if(!isWasmInitialized) {
17824 throw new Error("initializeWasm() must be awaited first!");
17826 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17827 return nativeResponseValue;
17829 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17831 export function ChainMonitor_as_Listen(this_arg: number): number {
17832 if(!isWasmInitialized) {
17833 throw new Error("initializeWasm() must be awaited first!");
17835 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17836 return nativeResponseValue;
17838 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17840 export function ChainMonitor_as_Confirm(this_arg: number): number {
17841 if(!isWasmInitialized) {
17842 throw new Error("initializeWasm() must be awaited first!");
17844 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17845 return nativeResponseValue;
17847 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17849 export function ChainMonitor_as_Watch(this_arg: number): number {
17850 if(!isWasmInitialized) {
17851 throw new Error("initializeWasm() must be awaited first!");
17853 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17854 return nativeResponseValue;
17856 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17858 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
17859 if(!isWasmInitialized) {
17860 throw new Error("initializeWasm() must be awaited first!");
17862 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17863 return nativeResponseValue;
17865 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17867 export function ChannelMonitorUpdate_free(this_obj: number): void {
17868 if(!isWasmInitialized) {
17869 throw new Error("initializeWasm() must be awaited first!");
17871 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17872 // debug statements here
17874 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17876 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
17877 if(!isWasmInitialized) {
17878 throw new Error("initializeWasm() must be awaited first!");
17880 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17881 return nativeResponseValue;
17883 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17885 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
17886 if(!isWasmInitialized) {
17887 throw new Error("initializeWasm() must be awaited first!");
17889 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17890 // debug statements here
17892 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17894 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
17895 if(!isWasmInitialized) {
17896 throw new Error("initializeWasm() must be awaited first!");
17898 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17899 return nativeResponseValue;
17901 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17903 export function ChannelMonitorUpdate_clone(orig: number): number {
17904 if(!isWasmInitialized) {
17905 throw new Error("initializeWasm() must be awaited first!");
17907 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17908 return nativeResponseValue;
17910 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17912 export function ChannelMonitorUpdate_write(obj: number): number {
17913 if(!isWasmInitialized) {
17914 throw new Error("initializeWasm() must be awaited first!");
17916 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17917 return nativeResponseValue;
17919 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17921 export function ChannelMonitorUpdate_read(ser: number): number {
17922 if(!isWasmInitialized) {
17923 throw new Error("initializeWasm() must be awaited first!");
17925 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17926 return nativeResponseValue;
17928 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17930 export function MonitorEvent_free(this_ptr: number): void {
17931 if(!isWasmInitialized) {
17932 throw new Error("initializeWasm() must be awaited first!");
17934 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17935 // debug statements here
17937 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17939 export function MonitorEvent_clone_ptr(arg: number): number {
17940 if(!isWasmInitialized) {
17941 throw new Error("initializeWasm() must be awaited first!");
17943 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17944 return nativeResponseValue;
17946 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17948 export function MonitorEvent_clone(orig: number): number {
17949 if(!isWasmInitialized) {
17950 throw new Error("initializeWasm() must be awaited first!");
17952 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17953 return nativeResponseValue;
17955 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17957 export function MonitorEvent_htlcevent(a: number): number {
17958 if(!isWasmInitialized) {
17959 throw new Error("initializeWasm() must be awaited first!");
17961 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17962 return nativeResponseValue;
17964 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17966 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
17967 if(!isWasmInitialized) {
17968 throw new Error("initializeWasm() must be awaited first!");
17970 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17971 return nativeResponseValue;
17973 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17975 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
17976 if(!isWasmInitialized) {
17977 throw new Error("initializeWasm() must be awaited first!");
17979 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17980 return nativeResponseValue;
17982 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17984 export function MonitorEvent_update_failed(a: number): number {
17985 if(!isWasmInitialized) {
17986 throw new Error("initializeWasm() must be awaited first!");
17988 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17989 return nativeResponseValue;
17991 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
17993 export function MonitorEvent_write(obj: number): number {
17994 if(!isWasmInitialized) {
17995 throw new Error("initializeWasm() must be awaited first!");
17997 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
17998 return nativeResponseValue;
18000 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
18002 export function MonitorEvent_read(ser: number): number {
18003 if(!isWasmInitialized) {
18004 throw new Error("initializeWasm() must be awaited first!");
18006 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
18007 return nativeResponseValue;
18009 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
18011 export function HTLCUpdate_free(this_obj: number): void {
18012 if(!isWasmInitialized) {
18013 throw new Error("initializeWasm() must be awaited first!");
18015 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
18016 // debug statements here
18018 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
18020 export function HTLCUpdate_clone_ptr(arg: number): number {
18021 if(!isWasmInitialized) {
18022 throw new Error("initializeWasm() must be awaited first!");
18024 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
18025 return nativeResponseValue;
18027 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
18029 export function HTLCUpdate_clone(orig: number): number {
18030 if(!isWasmInitialized) {
18031 throw new Error("initializeWasm() must be awaited first!");
18033 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
18034 return nativeResponseValue;
18036 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
18038 export function HTLCUpdate_write(obj: number): number {
18039 if(!isWasmInitialized) {
18040 throw new Error("initializeWasm() must be awaited first!");
18042 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
18043 return nativeResponseValue;
18045 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
18047 export function HTLCUpdate_read(ser: number): number {
18048 if(!isWasmInitialized) {
18049 throw new Error("initializeWasm() must be awaited first!");
18051 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
18052 return nativeResponseValue;
18054 // void Balance_free(struct LDKBalance this_ptr);
18056 export function Balance_free(this_ptr: number): void {
18057 if(!isWasmInitialized) {
18058 throw new Error("initializeWasm() must be awaited first!");
18060 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
18061 // debug statements here
18063 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
18065 export function Balance_clone_ptr(arg: number): number {
18066 if(!isWasmInitialized) {
18067 throw new Error("initializeWasm() must be awaited first!");
18069 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
18070 return nativeResponseValue;
18072 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
18074 export function Balance_clone(orig: number): number {
18075 if(!isWasmInitialized) {
18076 throw new Error("initializeWasm() must be awaited first!");
18078 const nativeResponseValue = wasm.TS_Balance_clone(orig);
18079 return nativeResponseValue;
18081 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
18083 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
18084 if(!isWasmInitialized) {
18085 throw new Error("initializeWasm() must be awaited first!");
18087 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
18088 return nativeResponseValue;
18090 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
18092 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
18093 if(!isWasmInitialized) {
18094 throw new Error("initializeWasm() must be awaited first!");
18096 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
18097 return nativeResponseValue;
18099 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
18101 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
18102 if(!isWasmInitialized) {
18103 throw new Error("initializeWasm() must be awaited first!");
18105 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
18106 return nativeResponseValue;
18108 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
18110 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
18111 if(!isWasmInitialized) {
18112 throw new Error("initializeWasm() must be awaited first!");
18114 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
18115 return nativeResponseValue;
18117 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
18119 export function Balance_eq(a: number, b: number): boolean {
18120 if(!isWasmInitialized) {
18121 throw new Error("initializeWasm() must be awaited first!");
18123 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
18124 return nativeResponseValue;
18126 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
18128 export function ChannelMonitor_free(this_obj: number): void {
18129 if(!isWasmInitialized) {
18130 throw new Error("initializeWasm() must be awaited first!");
18132 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
18133 // debug statements here
18135 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
18137 export function ChannelMonitor_clone_ptr(arg: number): number {
18138 if(!isWasmInitialized) {
18139 throw new Error("initializeWasm() must be awaited first!");
18141 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
18142 return nativeResponseValue;
18144 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
18146 export function ChannelMonitor_clone(orig: number): number {
18147 if(!isWasmInitialized) {
18148 throw new Error("initializeWasm() must be awaited first!");
18150 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
18151 return nativeResponseValue;
18153 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
18155 export function ChannelMonitor_write(obj: number): number {
18156 if(!isWasmInitialized) {
18157 throw new Error("initializeWasm() must be awaited first!");
18159 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
18160 return nativeResponseValue;
18162 // 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);
18164 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
18165 if(!isWasmInitialized) {
18166 throw new Error("initializeWasm() must be awaited first!");
18168 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
18169 return nativeResponseValue;
18171 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18173 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
18174 if(!isWasmInitialized) {
18175 throw new Error("initializeWasm() must be awaited first!");
18177 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
18178 return nativeResponseValue;
18180 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18182 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
18183 if(!isWasmInitialized) {
18184 throw new Error("initializeWasm() must be awaited first!");
18186 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
18187 return nativeResponseValue;
18189 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18191 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
18192 if(!isWasmInitialized) {
18193 throw new Error("initializeWasm() must be awaited first!");
18195 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
18196 return nativeResponseValue;
18198 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
18200 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
18201 if(!isWasmInitialized) {
18202 throw new Error("initializeWasm() must be awaited first!");
18204 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
18205 // debug statements here
18207 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18209 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
18210 if(!isWasmInitialized) {
18211 throw new Error("initializeWasm() must be awaited first!");
18213 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
18214 return nativeResponseValue;
18216 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18218 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
18219 if(!isWasmInitialized) {
18220 throw new Error("initializeWasm() must be awaited first!");
18222 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
18223 return nativeResponseValue;
18225 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18227 export function ChannelMonitor_get_counterparty_node_id(this_arg: number): number {
18228 if(!isWasmInitialized) {
18229 throw new Error("initializeWasm() must be awaited first!");
18231 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
18232 return nativeResponseValue;
18234 // 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);
18236 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
18237 if(!isWasmInitialized) {
18238 throw new Error("initializeWasm() must be awaited first!");
18240 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
18241 return nativeResponseValue;
18243 // 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);
18245 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
18246 if(!isWasmInitialized) {
18247 throw new Error("initializeWasm() must be awaited first!");
18249 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
18250 return nativeResponseValue;
18252 // 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);
18254 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
18255 if(!isWasmInitialized) {
18256 throw new Error("initializeWasm() must be awaited first!");
18258 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
18259 // debug statements here
18261 // 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);
18263 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
18264 if(!isWasmInitialized) {
18265 throw new Error("initializeWasm() must be awaited first!");
18267 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
18268 return nativeResponseValue;
18270 // 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);
18272 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
18273 if(!isWasmInitialized) {
18274 throw new Error("initializeWasm() must be awaited first!");
18276 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
18277 // debug statements here
18279 // 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);
18281 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
18282 if(!isWasmInitialized) {
18283 throw new Error("initializeWasm() must be awaited first!");
18285 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
18286 return nativeResponseValue;
18288 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18290 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
18291 if(!isWasmInitialized) {
18292 throw new Error("initializeWasm() must be awaited first!");
18294 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
18295 return nativeResponseValue;
18297 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18299 export function ChannelMonitor_current_best_block(this_arg: number): number {
18300 if(!isWasmInitialized) {
18301 throw new Error("initializeWasm() must be awaited first!");
18303 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
18304 return nativeResponseValue;
18306 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18308 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
18309 if(!isWasmInitialized) {
18310 throw new Error("initializeWasm() must be awaited first!");
18312 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
18313 return nativeResponseValue;
18315 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
18317 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
18318 if(!isWasmInitialized) {
18319 throw new Error("initializeWasm() must be awaited first!");
18321 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
18322 return nativeResponseValue;
18324 // void OutPoint_free(struct LDKOutPoint this_obj);
18326 export function OutPoint_free(this_obj: number): void {
18327 if(!isWasmInitialized) {
18328 throw new Error("initializeWasm() must be awaited first!");
18330 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
18331 // debug statements here
18333 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
18335 export function OutPoint_get_txid(this_ptr: number): number {
18336 if(!isWasmInitialized) {
18337 throw new Error("initializeWasm() must be awaited first!");
18339 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
18340 return nativeResponseValue;
18342 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18344 export function OutPoint_set_txid(this_ptr: number, val: number): void {
18345 if(!isWasmInitialized) {
18346 throw new Error("initializeWasm() must be awaited first!");
18348 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
18349 // debug statements here
18351 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
18353 export function OutPoint_get_index(this_ptr: number): number {
18354 if(!isWasmInitialized) {
18355 throw new Error("initializeWasm() must be awaited first!");
18357 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
18358 return nativeResponseValue;
18360 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
18362 export function OutPoint_set_index(this_ptr: number, val: number): void {
18363 if(!isWasmInitialized) {
18364 throw new Error("initializeWasm() must be awaited first!");
18366 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
18367 // debug statements here
18369 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
18371 export function OutPoint_new(txid_arg: number, index_arg: number): number {
18372 if(!isWasmInitialized) {
18373 throw new Error("initializeWasm() must be awaited first!");
18375 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
18376 return nativeResponseValue;
18378 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
18380 export function OutPoint_clone_ptr(arg: number): number {
18381 if(!isWasmInitialized) {
18382 throw new Error("initializeWasm() must be awaited first!");
18384 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
18385 return nativeResponseValue;
18387 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
18389 export function OutPoint_clone(orig: number): number {
18390 if(!isWasmInitialized) {
18391 throw new Error("initializeWasm() must be awaited first!");
18393 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
18394 return nativeResponseValue;
18396 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
18398 export function OutPoint_eq(a: number, b: number): boolean {
18399 if(!isWasmInitialized) {
18400 throw new Error("initializeWasm() must be awaited first!");
18402 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
18403 return nativeResponseValue;
18405 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
18407 export function OutPoint_hash(o: number): bigint {
18408 if(!isWasmInitialized) {
18409 throw new Error("initializeWasm() must be awaited first!");
18411 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
18412 return nativeResponseValue;
18414 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
18416 export function OutPoint_to_channel_id(this_arg: number): number {
18417 if(!isWasmInitialized) {
18418 throw new Error("initializeWasm() must be awaited first!");
18420 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
18421 return nativeResponseValue;
18423 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
18425 export function OutPoint_write(obj: number): number {
18426 if(!isWasmInitialized) {
18427 throw new Error("initializeWasm() must be awaited first!");
18429 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
18430 return nativeResponseValue;
18432 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
18434 export function OutPoint_read(ser: number): number {
18435 if(!isWasmInitialized) {
18436 throw new Error("initializeWasm() must be awaited first!");
18438 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
18439 return nativeResponseValue;
18441 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
18443 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
18444 if(!isWasmInitialized) {
18445 throw new Error("initializeWasm() must be awaited first!");
18447 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
18448 // debug statements here
18450 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18452 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
18453 if(!isWasmInitialized) {
18454 throw new Error("initializeWasm() must be awaited first!");
18456 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
18457 return nativeResponseValue;
18459 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18461 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
18462 if(!isWasmInitialized) {
18463 throw new Error("initializeWasm() must be awaited first!");
18465 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18466 // debug statements here
18468 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18470 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
18471 if(!isWasmInitialized) {
18472 throw new Error("initializeWasm() must be awaited first!");
18474 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
18475 return nativeResponseValue;
18477 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18479 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
18480 if(!isWasmInitialized) {
18481 throw new Error("initializeWasm() must be awaited first!");
18483 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
18484 // debug statements here
18486 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18488 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
18489 if(!isWasmInitialized) {
18490 throw new Error("initializeWasm() must be awaited first!");
18492 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
18493 return nativeResponseValue;
18495 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
18497 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
18498 if(!isWasmInitialized) {
18499 throw new Error("initializeWasm() must be awaited first!");
18501 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
18502 // debug statements here
18504 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18506 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: number): number {
18507 if(!isWasmInitialized) {
18508 throw new Error("initializeWasm() must be awaited first!");
18510 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
18511 return nativeResponseValue;
18513 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18515 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18516 if(!isWasmInitialized) {
18517 throw new Error("initializeWasm() must be awaited first!");
18519 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
18520 // debug statements here
18522 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18524 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
18525 if(!isWasmInitialized) {
18526 throw new Error("initializeWasm() must be awaited first!");
18528 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
18529 return nativeResponseValue;
18531 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18533 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
18534 if(!isWasmInitialized) {
18535 throw new Error("initializeWasm() must be awaited first!");
18537 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
18538 // debug statements here
18540 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18542 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18543 if(!isWasmInitialized) {
18544 throw new Error("initializeWasm() must be awaited first!");
18546 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18547 return nativeResponseValue;
18549 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18551 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18552 if(!isWasmInitialized) {
18553 throw new Error("initializeWasm() must be awaited first!");
18555 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18556 // debug statements here
18558 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18560 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18561 if(!isWasmInitialized) {
18562 throw new Error("initializeWasm() must be awaited first!");
18564 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18565 return nativeResponseValue;
18567 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18569 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18570 if(!isWasmInitialized) {
18571 throw new Error("initializeWasm() must be awaited first!");
18573 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18574 // debug statements here
18576 // 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);
18578 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: number, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: number, revocation_pubkey_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
18579 if(!isWasmInitialized) {
18580 throw new Error("initializeWasm() must be awaited first!");
18582 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);
18583 return nativeResponseValue;
18585 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
18587 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
18588 if(!isWasmInitialized) {
18589 throw new Error("initializeWasm() must be awaited first!");
18591 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
18592 return nativeResponseValue;
18594 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
18596 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
18597 if(!isWasmInitialized) {
18598 throw new Error("initializeWasm() must be awaited first!");
18600 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
18601 return nativeResponseValue;
18603 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
18605 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
18606 if(!isWasmInitialized) {
18607 throw new Error("initializeWasm() must be awaited first!");
18609 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
18610 return nativeResponseValue;
18612 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
18614 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
18615 if(!isWasmInitialized) {
18616 throw new Error("initializeWasm() must be awaited first!");
18618 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
18619 return nativeResponseValue;
18621 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
18623 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
18624 if(!isWasmInitialized) {
18625 throw new Error("initializeWasm() must be awaited first!");
18627 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
18628 // debug statements here
18630 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18632 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
18633 if(!isWasmInitialized) {
18634 throw new Error("initializeWasm() must be awaited first!");
18636 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
18637 return nativeResponseValue;
18639 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18641 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
18642 if(!isWasmInitialized) {
18643 throw new Error("initializeWasm() must be awaited first!");
18645 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18646 // debug statements here
18648 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18650 export function StaticPaymentOutputDescriptor_get_output(this_ptr: number): number {
18651 if(!isWasmInitialized) {
18652 throw new Error("initializeWasm() must be awaited first!");
18654 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
18655 return nativeResponseValue;
18657 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18659 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18660 if(!isWasmInitialized) {
18661 throw new Error("initializeWasm() must be awaited first!");
18663 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
18664 // debug statements here
18666 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18668 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18669 if(!isWasmInitialized) {
18670 throw new Error("initializeWasm() must be awaited first!");
18672 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18673 return nativeResponseValue;
18675 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18677 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18678 if(!isWasmInitialized) {
18679 throw new Error("initializeWasm() must be awaited first!");
18681 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18682 // debug statements here
18684 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18686 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18687 if(!isWasmInitialized) {
18688 throw new Error("initializeWasm() must be awaited first!");
18690 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18691 return nativeResponseValue;
18693 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18695 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18696 if(!isWasmInitialized) {
18697 throw new Error("initializeWasm() must be awaited first!");
18699 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18700 // debug statements here
18702 // 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);
18704 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
18705 if(!isWasmInitialized) {
18706 throw new Error("initializeWasm() must be awaited first!");
18708 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
18709 return nativeResponseValue;
18711 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
18713 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
18714 if(!isWasmInitialized) {
18715 throw new Error("initializeWasm() must be awaited first!");
18717 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
18718 return nativeResponseValue;
18720 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
18722 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
18723 if(!isWasmInitialized) {
18724 throw new Error("initializeWasm() must be awaited first!");
18726 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
18727 return nativeResponseValue;
18729 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18731 export function StaticPaymentOutputDescriptor_write(obj: number): number {
18732 if(!isWasmInitialized) {
18733 throw new Error("initializeWasm() must be awaited first!");
18735 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18736 return nativeResponseValue;
18738 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18740 export function StaticPaymentOutputDescriptor_read(ser: number): number {
18741 if(!isWasmInitialized) {
18742 throw new Error("initializeWasm() must be awaited first!");
18744 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18745 return nativeResponseValue;
18747 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18749 export function SpendableOutputDescriptor_free(this_ptr: number): void {
18750 if(!isWasmInitialized) {
18751 throw new Error("initializeWasm() must be awaited first!");
18753 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18754 // debug statements here
18756 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18758 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
18759 if(!isWasmInitialized) {
18760 throw new Error("initializeWasm() must be awaited first!");
18762 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18763 return nativeResponseValue;
18765 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18767 export function SpendableOutputDescriptor_clone(orig: number): number {
18768 if(!isWasmInitialized) {
18769 throw new Error("initializeWasm() must be awaited first!");
18771 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18772 return nativeResponseValue;
18774 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18776 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
18777 if(!isWasmInitialized) {
18778 throw new Error("initializeWasm() must be awaited first!");
18780 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18781 return nativeResponseValue;
18783 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18785 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
18786 if(!isWasmInitialized) {
18787 throw new Error("initializeWasm() must be awaited first!");
18789 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18790 return nativeResponseValue;
18792 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18794 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
18795 if(!isWasmInitialized) {
18796 throw new Error("initializeWasm() must be awaited first!");
18798 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18799 return nativeResponseValue;
18801 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18803 export function SpendableOutputDescriptor_write(obj: number): number {
18804 if(!isWasmInitialized) {
18805 throw new Error("initializeWasm() must be awaited first!");
18807 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18808 return nativeResponseValue;
18810 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18812 export function SpendableOutputDescriptor_read(ser: number): number {
18813 if(!isWasmInitialized) {
18814 throw new Error("initializeWasm() must be awaited first!");
18816 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18817 return nativeResponseValue;
18819 // void BaseSign_free(struct LDKBaseSign this_ptr);
18821 export function BaseSign_free(this_ptr: number): void {
18822 if(!isWasmInitialized) {
18823 throw new Error("initializeWasm() must be awaited first!");
18825 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18826 // debug statements here
18828 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18830 export function Sign_clone_ptr(arg: number): number {
18831 if(!isWasmInitialized) {
18832 throw new Error("initializeWasm() must be awaited first!");
18834 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18835 return nativeResponseValue;
18837 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18839 export function Sign_clone(orig: number): number {
18840 if(!isWasmInitialized) {
18841 throw new Error("initializeWasm() must be awaited first!");
18843 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18844 return nativeResponseValue;
18846 // void Sign_free(struct LDKSign this_ptr);
18848 export function Sign_free(this_ptr: number): void {
18849 if(!isWasmInitialized) {
18850 throw new Error("initializeWasm() must be awaited first!");
18852 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18853 // debug statements here
18855 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18857 export function Recipient_clone(orig: number): Recipient {
18858 if(!isWasmInitialized) {
18859 throw new Error("initializeWasm() must be awaited first!");
18861 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18862 return nativeResponseValue;
18864 // enum LDKRecipient Recipient_node(void);
18866 export function Recipient_node(): Recipient {
18867 if(!isWasmInitialized) {
18868 throw new Error("initializeWasm() must be awaited first!");
18870 const nativeResponseValue = wasm.TS_Recipient_node();
18871 return nativeResponseValue;
18873 // enum LDKRecipient Recipient_phantom_node(void);
18875 export function Recipient_phantom_node(): Recipient {
18876 if(!isWasmInitialized) {
18877 throw new Error("initializeWasm() must be awaited first!");
18879 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18880 return nativeResponseValue;
18882 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18884 export function KeysInterface_free(this_ptr: number): void {
18885 if(!isWasmInitialized) {
18886 throw new Error("initializeWasm() must be awaited first!");
18888 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18889 // debug statements here
18891 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18893 export function InMemorySigner_free(this_obj: number): void {
18894 if(!isWasmInitialized) {
18895 throw new Error("initializeWasm() must be awaited first!");
18897 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18898 // debug statements here
18900 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18902 export function InMemorySigner_get_funding_key(this_ptr: number): number {
18903 if(!isWasmInitialized) {
18904 throw new Error("initializeWasm() must be awaited first!");
18906 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18907 return nativeResponseValue;
18909 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18911 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
18912 if(!isWasmInitialized) {
18913 throw new Error("initializeWasm() must be awaited first!");
18915 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18916 // debug statements here
18918 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18920 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
18921 if(!isWasmInitialized) {
18922 throw new Error("initializeWasm() must be awaited first!");
18924 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18925 return nativeResponseValue;
18927 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18929 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
18930 if(!isWasmInitialized) {
18931 throw new Error("initializeWasm() must be awaited first!");
18933 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18934 // debug statements here
18936 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18938 export function InMemorySigner_get_payment_key(this_ptr: number): number {
18939 if(!isWasmInitialized) {
18940 throw new Error("initializeWasm() must be awaited first!");
18942 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18943 return nativeResponseValue;
18945 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18947 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
18948 if(!isWasmInitialized) {
18949 throw new Error("initializeWasm() must be awaited first!");
18951 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18952 // debug statements here
18954 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18956 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
18957 if(!isWasmInitialized) {
18958 throw new Error("initializeWasm() must be awaited first!");
18960 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18961 return nativeResponseValue;
18963 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18965 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
18966 if(!isWasmInitialized) {
18967 throw new Error("initializeWasm() must be awaited first!");
18969 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18970 // debug statements here
18972 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18974 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
18975 if(!isWasmInitialized) {
18976 throw new Error("initializeWasm() must be awaited first!");
18978 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18979 return nativeResponseValue;
18981 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18983 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
18984 if(!isWasmInitialized) {
18985 throw new Error("initializeWasm() must be awaited first!");
18987 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18988 // debug statements here
18990 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18992 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
18993 if(!isWasmInitialized) {
18994 throw new Error("initializeWasm() must be awaited first!");
18996 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
18997 return nativeResponseValue;
18999 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19001 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
19002 if(!isWasmInitialized) {
19003 throw new Error("initializeWasm() must be awaited first!");
19005 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
19006 // debug statements here
19008 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
19010 export function InMemorySigner_clone_ptr(arg: number): number {
19011 if(!isWasmInitialized) {
19012 throw new Error("initializeWasm() must be awaited first!");
19014 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
19015 return nativeResponseValue;
19017 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
19019 export function InMemorySigner_clone(orig: number): number {
19020 if(!isWasmInitialized) {
19021 throw new Error("initializeWasm() must be awaited first!");
19023 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
19024 return nativeResponseValue;
19026 // 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);
19028 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): number {
19029 if(!isWasmInitialized) {
19030 throw new Error("initializeWasm() must be awaited first!");
19032 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);
19033 return nativeResponseValue;
19035 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19037 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
19038 if(!isWasmInitialized) {
19039 throw new Error("initializeWasm() must be awaited first!");
19041 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
19042 return nativeResponseValue;
19044 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19046 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
19047 if(!isWasmInitialized) {
19048 throw new Error("initializeWasm() must be awaited first!");
19050 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
19051 return nativeResponseValue;
19053 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19055 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
19056 if(!isWasmInitialized) {
19057 throw new Error("initializeWasm() must be awaited first!");
19059 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
19060 return nativeResponseValue;
19062 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19064 export function InMemorySigner_is_outbound(this_arg: number): boolean {
19065 if(!isWasmInitialized) {
19066 throw new Error("initializeWasm() must be awaited first!");
19068 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
19069 return nativeResponseValue;
19071 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19073 export function InMemorySigner_funding_outpoint(this_arg: number): number {
19074 if(!isWasmInitialized) {
19075 throw new Error("initializeWasm() must be awaited first!");
19077 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
19078 return nativeResponseValue;
19080 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19082 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
19083 if(!isWasmInitialized) {
19084 throw new Error("initializeWasm() must be awaited first!");
19086 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
19087 return nativeResponseValue;
19089 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19091 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
19092 if(!isWasmInitialized) {
19093 throw new Error("initializeWasm() must be awaited first!");
19095 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
19096 return nativeResponseValue;
19098 // 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);
19100 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
19101 if(!isWasmInitialized) {
19102 throw new Error("initializeWasm() must be awaited first!");
19104 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
19105 return nativeResponseValue;
19107 // 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);
19109 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
19110 if(!isWasmInitialized) {
19111 throw new Error("initializeWasm() must be awaited first!");
19113 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
19114 return nativeResponseValue;
19116 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19118 export function InMemorySigner_as_BaseSign(this_arg: number): number {
19119 if(!isWasmInitialized) {
19120 throw new Error("initializeWasm() must be awaited first!");
19122 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
19123 return nativeResponseValue;
19125 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19127 export function InMemorySigner_as_Sign(this_arg: number): number {
19128 if(!isWasmInitialized) {
19129 throw new Error("initializeWasm() must be awaited first!");
19131 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
19132 return nativeResponseValue;
19134 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
19136 export function InMemorySigner_write(obj: number): number {
19137 if(!isWasmInitialized) {
19138 throw new Error("initializeWasm() must be awaited first!");
19140 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
19141 return nativeResponseValue;
19143 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
19145 export function InMemorySigner_read(ser: number, arg: number): number {
19146 if(!isWasmInitialized) {
19147 throw new Error("initializeWasm() must be awaited first!");
19149 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
19150 return nativeResponseValue;
19152 // void KeysManager_free(struct LDKKeysManager this_obj);
19154 export function KeysManager_free(this_obj: number): void {
19155 if(!isWasmInitialized) {
19156 throw new Error("initializeWasm() must be awaited first!");
19158 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
19159 // debug statements here
19161 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
19163 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
19164 if(!isWasmInitialized) {
19165 throw new Error("initializeWasm() must be awaited first!");
19167 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
19168 return nativeResponseValue;
19170 // 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]);
19172 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
19173 if(!isWasmInitialized) {
19174 throw new Error("initializeWasm() must be awaited first!");
19176 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
19177 return nativeResponseValue;
19179 // 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);
19181 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
19182 if(!isWasmInitialized) {
19183 throw new Error("initializeWasm() must be awaited first!");
19185 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
19186 return nativeResponseValue;
19188 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
19190 export function KeysManager_as_KeysInterface(this_arg: number): number {
19191 if(!isWasmInitialized) {
19192 throw new Error("initializeWasm() must be awaited first!");
19194 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
19195 return nativeResponseValue;
19197 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
19199 export function PhantomKeysManager_free(this_obj: number): void {
19200 if(!isWasmInitialized) {
19201 throw new Error("initializeWasm() must be awaited first!");
19203 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
19204 // debug statements here
19206 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
19208 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
19209 if(!isWasmInitialized) {
19210 throw new Error("initializeWasm() must be awaited first!");
19212 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
19213 return nativeResponseValue;
19215 // 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]);
19217 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
19218 if(!isWasmInitialized) {
19219 throw new Error("initializeWasm() must be awaited first!");
19221 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
19222 return nativeResponseValue;
19224 // 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);
19226 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
19227 if(!isWasmInitialized) {
19228 throw new Error("initializeWasm() must be awaited first!");
19230 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
19231 return nativeResponseValue;
19233 // 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]);
19235 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
19236 if(!isWasmInitialized) {
19237 throw new Error("initializeWasm() must be awaited first!");
19239 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
19240 return nativeResponseValue;
19242 // void ChannelManager_free(struct LDKChannelManager this_obj);
19244 export function ChannelManager_free(this_obj: number): void {
19245 if(!isWasmInitialized) {
19246 throw new Error("initializeWasm() must be awaited first!");
19248 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
19249 // debug statements here
19251 // void ChainParameters_free(struct LDKChainParameters this_obj);
19253 export function ChainParameters_free(this_obj: number): void {
19254 if(!isWasmInitialized) {
19255 throw new Error("initializeWasm() must be awaited first!");
19257 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
19258 // debug statements here
19260 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
19262 export function ChainParameters_get_network(this_ptr: number): Network {
19263 if(!isWasmInitialized) {
19264 throw new Error("initializeWasm() must be awaited first!");
19266 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
19267 return nativeResponseValue;
19269 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
19271 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
19272 if(!isWasmInitialized) {
19273 throw new Error("initializeWasm() must be awaited first!");
19275 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
19276 // debug statements here
19278 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
19280 export function ChainParameters_get_best_block(this_ptr: number): number {
19281 if(!isWasmInitialized) {
19282 throw new Error("initializeWasm() must be awaited first!");
19284 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
19285 return nativeResponseValue;
19287 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
19289 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
19290 if(!isWasmInitialized) {
19291 throw new Error("initializeWasm() must be awaited first!");
19293 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
19294 // debug statements here
19296 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
19298 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
19299 if(!isWasmInitialized) {
19300 throw new Error("initializeWasm() must be awaited first!");
19302 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
19303 return nativeResponseValue;
19305 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
19307 export function ChainParameters_clone_ptr(arg: number): number {
19308 if(!isWasmInitialized) {
19309 throw new Error("initializeWasm() must be awaited first!");
19311 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
19312 return nativeResponseValue;
19314 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
19316 export function ChainParameters_clone(orig: number): number {
19317 if(!isWasmInitialized) {
19318 throw new Error("initializeWasm() must be awaited first!");
19320 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
19321 return nativeResponseValue;
19323 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
19325 export function CounterpartyForwardingInfo_free(this_obj: number): void {
19326 if(!isWasmInitialized) {
19327 throw new Error("initializeWasm() must be awaited first!");
19329 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
19330 // debug statements here
19332 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19334 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
19335 if(!isWasmInitialized) {
19336 throw new Error("initializeWasm() must be awaited first!");
19338 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
19339 return nativeResponseValue;
19341 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
19343 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
19344 if(!isWasmInitialized) {
19345 throw new Error("initializeWasm() must be awaited first!");
19347 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
19348 // debug statements here
19350 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19352 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
19353 if(!isWasmInitialized) {
19354 throw new Error("initializeWasm() must be awaited first!");
19356 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
19357 return nativeResponseValue;
19359 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
19361 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
19362 if(!isWasmInitialized) {
19363 throw new Error("initializeWasm() must be awaited first!");
19365 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
19366 // debug statements here
19368 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19370 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
19371 if(!isWasmInitialized) {
19372 throw new Error("initializeWasm() must be awaited first!");
19374 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
19375 return nativeResponseValue;
19377 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
19379 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
19380 if(!isWasmInitialized) {
19381 throw new Error("initializeWasm() must be awaited first!");
19383 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
19384 // debug statements here
19386 // 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);
19388 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
19389 if(!isWasmInitialized) {
19390 throw new Error("initializeWasm() must be awaited first!");
19392 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
19393 return nativeResponseValue;
19395 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
19397 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
19398 if(!isWasmInitialized) {
19399 throw new Error("initializeWasm() must be awaited first!");
19401 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
19402 return nativeResponseValue;
19404 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
19406 export function CounterpartyForwardingInfo_clone(orig: number): number {
19407 if(!isWasmInitialized) {
19408 throw new Error("initializeWasm() must be awaited first!");
19410 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
19411 return nativeResponseValue;
19413 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
19415 export function ChannelCounterparty_free(this_obj: number): void {
19416 if(!isWasmInitialized) {
19417 throw new Error("initializeWasm() must be awaited first!");
19419 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
19420 // debug statements here
19422 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19424 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
19425 if(!isWasmInitialized) {
19426 throw new Error("initializeWasm() must be awaited first!");
19428 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
19429 return nativeResponseValue;
19431 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19433 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
19434 if(!isWasmInitialized) {
19435 throw new Error("initializeWasm() must be awaited first!");
19437 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
19438 // debug statements here
19440 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19442 export function ChannelCounterparty_get_features(this_ptr: number): number {
19443 if(!isWasmInitialized) {
19444 throw new Error("initializeWasm() must be awaited first!");
19446 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
19447 return nativeResponseValue;
19449 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
19451 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
19452 if(!isWasmInitialized) {
19453 throw new Error("initializeWasm() must be awaited first!");
19455 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
19456 // debug statements here
19458 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19460 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
19461 if(!isWasmInitialized) {
19462 throw new Error("initializeWasm() must be awaited first!");
19464 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
19465 return nativeResponseValue;
19467 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
19469 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
19470 if(!isWasmInitialized) {
19471 throw new Error("initializeWasm() must be awaited first!");
19473 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
19474 // debug statements here
19476 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19478 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
19479 if(!isWasmInitialized) {
19480 throw new Error("initializeWasm() must be awaited first!");
19482 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
19483 return nativeResponseValue;
19485 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
19487 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
19488 if(!isWasmInitialized) {
19489 throw new Error("initializeWasm() must be awaited first!");
19491 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
19492 // debug statements here
19494 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19496 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: number): number {
19497 if(!isWasmInitialized) {
19498 throw new Error("initializeWasm() must be awaited first!");
19500 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
19501 return nativeResponseValue;
19503 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19505 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19506 if(!isWasmInitialized) {
19507 throw new Error("initializeWasm() must be awaited first!");
19509 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
19510 // debug statements here
19512 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19514 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: number): number {
19515 if(!isWasmInitialized) {
19516 throw new Error("initializeWasm() must be awaited first!");
19518 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
19519 return nativeResponseValue;
19521 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19523 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19524 if(!isWasmInitialized) {
19525 throw new Error("initializeWasm() must be awaited first!");
19527 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
19528 // debug statements here
19530 // 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);
19532 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number, outbound_htlc_minimum_msat_arg: number, outbound_htlc_maximum_msat_arg: number): number {
19533 if(!isWasmInitialized) {
19534 throw new Error("initializeWasm() must be awaited first!");
19536 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);
19537 return nativeResponseValue;
19539 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
19541 export function ChannelCounterparty_clone_ptr(arg: number): number {
19542 if(!isWasmInitialized) {
19543 throw new Error("initializeWasm() must be awaited first!");
19545 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
19546 return nativeResponseValue;
19548 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
19550 export function ChannelCounterparty_clone(orig: number): number {
19551 if(!isWasmInitialized) {
19552 throw new Error("initializeWasm() must be awaited first!");
19554 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
19555 return nativeResponseValue;
19557 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
19559 export function ChannelDetails_free(this_obj: number): void {
19560 if(!isWasmInitialized) {
19561 throw new Error("initializeWasm() must be awaited first!");
19563 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
19564 // debug statements here
19566 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
19568 export function ChannelDetails_get_channel_id(this_ptr: number): number {
19569 if(!isWasmInitialized) {
19570 throw new Error("initializeWasm() must be awaited first!");
19572 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
19573 return nativeResponseValue;
19575 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19577 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
19578 if(!isWasmInitialized) {
19579 throw new Error("initializeWasm() must be awaited first!");
19581 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
19582 // debug statements here
19584 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19586 export function ChannelDetails_get_counterparty(this_ptr: number): number {
19587 if(!isWasmInitialized) {
19588 throw new Error("initializeWasm() must be awaited first!");
19590 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
19591 return nativeResponseValue;
19593 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
19595 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
19596 if(!isWasmInitialized) {
19597 throw new Error("initializeWasm() must be awaited first!");
19599 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
19600 // debug statements here
19602 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19604 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
19605 if(!isWasmInitialized) {
19606 throw new Error("initializeWasm() must be awaited first!");
19608 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
19609 return nativeResponseValue;
19611 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19613 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
19614 if(!isWasmInitialized) {
19615 throw new Error("initializeWasm() must be awaited first!");
19617 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
19618 // debug statements here
19620 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19622 export function ChannelDetails_get_channel_type(this_ptr: number): number {
19623 if(!isWasmInitialized) {
19624 throw new Error("initializeWasm() must be awaited first!");
19626 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
19627 return nativeResponseValue;
19629 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19631 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
19632 if(!isWasmInitialized) {
19633 throw new Error("initializeWasm() must be awaited first!");
19635 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
19636 // debug statements here
19638 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19640 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
19641 if(!isWasmInitialized) {
19642 throw new Error("initializeWasm() must be awaited first!");
19644 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
19645 return nativeResponseValue;
19647 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19649 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
19650 if(!isWasmInitialized) {
19651 throw new Error("initializeWasm() must be awaited first!");
19653 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
19654 // debug statements here
19656 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19658 export function ChannelDetails_get_outbound_scid_alias(this_ptr: number): number {
19659 if(!isWasmInitialized) {
19660 throw new Error("initializeWasm() must be awaited first!");
19662 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
19663 return nativeResponseValue;
19665 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19667 export function ChannelDetails_set_outbound_scid_alias(this_ptr: number, val: number): void {
19668 if(!isWasmInitialized) {
19669 throw new Error("initializeWasm() must be awaited first!");
19671 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
19672 // debug statements here
19674 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19676 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
19677 if(!isWasmInitialized) {
19678 throw new Error("initializeWasm() must be awaited first!");
19680 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
19681 return nativeResponseValue;
19683 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19685 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
19686 if(!isWasmInitialized) {
19687 throw new Error("initializeWasm() must be awaited first!");
19689 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
19690 // debug statements here
19692 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19694 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
19695 if(!isWasmInitialized) {
19696 throw new Error("initializeWasm() must be awaited first!");
19698 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
19699 return nativeResponseValue;
19701 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19703 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
19704 if(!isWasmInitialized) {
19705 throw new Error("initializeWasm() must be awaited first!");
19707 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
19708 // debug statements here
19710 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19712 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
19713 if(!isWasmInitialized) {
19714 throw new Error("initializeWasm() must be awaited first!");
19716 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
19717 return nativeResponseValue;
19719 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19721 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
19722 if(!isWasmInitialized) {
19723 throw new Error("initializeWasm() must be awaited first!");
19725 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
19726 // debug statements here
19728 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19730 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
19731 if(!isWasmInitialized) {
19732 throw new Error("initializeWasm() must be awaited first!");
19734 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19735 return nativeResponseValue;
19737 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19739 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
19740 if(!isWasmInitialized) {
19741 throw new Error("initializeWasm() must be awaited first!");
19743 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19744 // debug statements here
19746 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19748 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
19749 if(!isWasmInitialized) {
19750 throw new Error("initializeWasm() must be awaited first!");
19752 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19753 return nativeResponseValue;
19755 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19757 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
19758 if(!isWasmInitialized) {
19759 throw new Error("initializeWasm() must be awaited first!");
19761 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19762 // debug statements here
19764 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19766 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
19767 if(!isWasmInitialized) {
19768 throw new Error("initializeWasm() must be awaited first!");
19770 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19771 return nativeResponseValue;
19773 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19775 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
19776 if(!isWasmInitialized) {
19777 throw new Error("initializeWasm() must be awaited first!");
19779 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19780 // debug statements here
19782 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19784 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: number): bigint {
19785 if(!isWasmInitialized) {
19786 throw new Error("initializeWasm() must be awaited first!");
19788 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19789 return nativeResponseValue;
19791 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19793 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: number, val: bigint): void {
19794 if(!isWasmInitialized) {
19795 throw new Error("initializeWasm() must be awaited first!");
19797 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19798 // debug statements here
19800 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19802 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
19803 if(!isWasmInitialized) {
19804 throw new Error("initializeWasm() must be awaited first!");
19806 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19807 return nativeResponseValue;
19809 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19811 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
19812 if(!isWasmInitialized) {
19813 throw new Error("initializeWasm() must be awaited first!");
19815 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19816 // debug statements here
19818 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19820 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
19821 if(!isWasmInitialized) {
19822 throw new Error("initializeWasm() must be awaited first!");
19824 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19825 return nativeResponseValue;
19827 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19829 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
19830 if(!isWasmInitialized) {
19831 throw new Error("initializeWasm() must be awaited first!");
19833 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19834 // debug statements here
19836 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19838 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
19839 if(!isWasmInitialized) {
19840 throw new Error("initializeWasm() must be awaited first!");
19842 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19843 return nativeResponseValue;
19845 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19847 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
19848 if(!isWasmInitialized) {
19849 throw new Error("initializeWasm() must be awaited first!");
19851 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19852 // debug statements here
19854 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19856 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
19857 if(!isWasmInitialized) {
19858 throw new Error("initializeWasm() must be awaited first!");
19860 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19861 return nativeResponseValue;
19863 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19865 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
19866 if(!isWasmInitialized) {
19867 throw new Error("initializeWasm() must be awaited first!");
19869 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19870 // debug statements here
19872 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19874 export function ChannelDetails_get_is_channel_ready(this_ptr: number): boolean {
19875 if(!isWasmInitialized) {
19876 throw new Error("initializeWasm() must be awaited first!");
19878 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19879 return nativeResponseValue;
19881 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19883 export function ChannelDetails_set_is_channel_ready(this_ptr: number, val: boolean): void {
19884 if(!isWasmInitialized) {
19885 throw new Error("initializeWasm() must be awaited first!");
19887 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19888 // debug statements here
19890 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19892 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
19893 if(!isWasmInitialized) {
19894 throw new Error("initializeWasm() must be awaited first!");
19896 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19897 return nativeResponseValue;
19899 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19901 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
19902 if(!isWasmInitialized) {
19903 throw new Error("initializeWasm() must be awaited first!");
19905 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19906 // debug statements here
19908 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19910 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
19911 if(!isWasmInitialized) {
19912 throw new Error("initializeWasm() must be awaited first!");
19914 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19915 return nativeResponseValue;
19917 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19919 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
19920 if(!isWasmInitialized) {
19921 throw new Error("initializeWasm() must be awaited first!");
19923 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19924 // debug statements here
19926 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19928 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: number): number {
19929 if(!isWasmInitialized) {
19930 throw new Error("initializeWasm() must be awaited first!");
19932 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19933 return nativeResponseValue;
19935 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19937 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19938 if(!isWasmInitialized) {
19939 throw new Error("initializeWasm() must be awaited first!");
19941 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19942 // debug statements here
19944 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19946 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: number): number {
19947 if(!isWasmInitialized) {
19948 throw new Error("initializeWasm() must be awaited first!");
19950 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19951 return nativeResponseValue;
19953 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19955 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19956 if(!isWasmInitialized) {
19957 throw new Error("initializeWasm() must be awaited first!");
19959 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19960 // debug statements here
19962 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19964 export function ChannelDetails_get_config(this_ptr: number): number {
19965 if(!isWasmInitialized) {
19966 throw new Error("initializeWasm() must be awaited first!");
19968 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
19969 return nativeResponseValue;
19971 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19973 export function ChannelDetails_set_config(this_ptr: number, val: number): void {
19974 if(!isWasmInitialized) {
19975 throw new Error("initializeWasm() must be awaited first!");
19977 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
19978 // debug statements here
19980 // 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);
19982 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: number, funding_txo_arg: number, channel_type_arg: number, short_channel_id_arg: number, outbound_scid_alias_arg: number, inbound_scid_alias_arg: number, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: number, 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: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: number, inbound_htlc_maximum_msat_arg: number, config_arg: number): number {
19983 if(!isWasmInitialized) {
19984 throw new Error("initializeWasm() must be awaited first!");
19986 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);
19987 return nativeResponseValue;
19989 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19991 export function ChannelDetails_clone_ptr(arg: number): number {
19992 if(!isWasmInitialized) {
19993 throw new Error("initializeWasm() must be awaited first!");
19995 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
19996 return nativeResponseValue;
19998 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
20000 export function ChannelDetails_clone(orig: number): number {
20001 if(!isWasmInitialized) {
20002 throw new Error("initializeWasm() must be awaited first!");
20004 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
20005 return nativeResponseValue;
20007 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
20009 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
20010 if(!isWasmInitialized) {
20011 throw new Error("initializeWasm() must be awaited first!");
20013 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
20014 return nativeResponseValue;
20016 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
20018 export function ChannelDetails_get_outbound_payment_scid(this_arg: number): number {
20019 if(!isWasmInitialized) {
20020 throw new Error("initializeWasm() must be awaited first!");
20022 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
20023 return nativeResponseValue;
20025 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
20027 export function PaymentSendFailure_free(this_ptr: number): void {
20028 if(!isWasmInitialized) {
20029 throw new Error("initializeWasm() must be awaited first!");
20031 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
20032 // debug statements here
20034 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
20036 export function PaymentSendFailure_clone_ptr(arg: number): number {
20037 if(!isWasmInitialized) {
20038 throw new Error("initializeWasm() must be awaited first!");
20040 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
20041 return nativeResponseValue;
20043 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
20045 export function PaymentSendFailure_clone(orig: number): number {
20046 if(!isWasmInitialized) {
20047 throw new Error("initializeWasm() must be awaited first!");
20049 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
20050 return nativeResponseValue;
20052 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
20054 export function PaymentSendFailure_parameter_error(a: number): number {
20055 if(!isWasmInitialized) {
20056 throw new Error("initializeWasm() must be awaited first!");
20058 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
20059 return nativeResponseValue;
20061 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
20063 export function PaymentSendFailure_path_parameter_error(a: number): number {
20064 if(!isWasmInitialized) {
20065 throw new Error("initializeWasm() must be awaited first!");
20067 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
20068 return nativeResponseValue;
20070 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
20072 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
20073 if(!isWasmInitialized) {
20074 throw new Error("initializeWasm() must be awaited first!");
20076 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
20077 return nativeResponseValue;
20079 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
20081 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
20082 if(!isWasmInitialized) {
20083 throw new Error("initializeWasm() must be awaited first!");
20085 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
20086 return nativeResponseValue;
20088 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
20090 export function PhantomRouteHints_free(this_obj: number): void {
20091 if(!isWasmInitialized) {
20092 throw new Error("initializeWasm() must be awaited first!");
20094 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
20095 // debug statements here
20097 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20099 export function PhantomRouteHints_get_channels(this_ptr: number): number {
20100 if(!isWasmInitialized) {
20101 throw new Error("initializeWasm() must be awaited first!");
20103 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
20104 return nativeResponseValue;
20106 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
20108 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
20109 if(!isWasmInitialized) {
20110 throw new Error("initializeWasm() must be awaited first!");
20112 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
20113 // debug statements here
20115 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20117 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
20118 if(!isWasmInitialized) {
20119 throw new Error("initializeWasm() must be awaited first!");
20121 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
20122 return nativeResponseValue;
20124 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
20126 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
20127 if(!isWasmInitialized) {
20128 throw new Error("initializeWasm() must be awaited first!");
20130 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
20131 // debug statements here
20133 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20135 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
20136 if(!isWasmInitialized) {
20137 throw new Error("initializeWasm() must be awaited first!");
20139 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
20140 return nativeResponseValue;
20142 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20144 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
20145 if(!isWasmInitialized) {
20146 throw new Error("initializeWasm() must be awaited first!");
20148 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
20149 // debug statements here
20151 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
20153 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
20154 if(!isWasmInitialized) {
20155 throw new Error("initializeWasm() must be awaited first!");
20157 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
20158 return nativeResponseValue;
20160 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
20162 export function PhantomRouteHints_clone_ptr(arg: number): number {
20163 if(!isWasmInitialized) {
20164 throw new Error("initializeWasm() must be awaited first!");
20166 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
20167 return nativeResponseValue;
20169 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
20171 export function PhantomRouteHints_clone(orig: number): number {
20172 if(!isWasmInitialized) {
20173 throw new Error("initializeWasm() must be awaited first!");
20175 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
20176 return nativeResponseValue;
20178 // 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);
20180 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
20181 if(!isWasmInitialized) {
20182 throw new Error("initializeWasm() must be awaited first!");
20184 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
20185 return nativeResponseValue;
20187 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
20189 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
20190 if(!isWasmInitialized) {
20191 throw new Error("initializeWasm() must be awaited first!");
20193 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
20194 return nativeResponseValue;
20196 // 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);
20198 export function ChannelManager_create_channel(this_arg: number, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: bigint, override_config: number): number {
20199 if(!isWasmInitialized) {
20200 throw new Error("initializeWasm() must be awaited first!");
20202 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
20203 return nativeResponseValue;
20205 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
20207 export function ChannelManager_list_channels(this_arg: number): number {
20208 if(!isWasmInitialized) {
20209 throw new Error("initializeWasm() must be awaited first!");
20211 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
20212 return nativeResponseValue;
20214 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
20216 export function ChannelManager_list_usable_channels(this_arg: number): number {
20217 if(!isWasmInitialized) {
20218 throw new Error("initializeWasm() must be awaited first!");
20220 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
20221 return nativeResponseValue;
20223 // 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);
20225 export function ChannelManager_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
20226 if(!isWasmInitialized) {
20227 throw new Error("initializeWasm() must be awaited first!");
20229 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
20230 return nativeResponseValue;
20232 // 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);
20234 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: number): number {
20235 if(!isWasmInitialized) {
20236 throw new Error("initializeWasm() must be awaited first!");
20238 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
20239 return nativeResponseValue;
20241 // 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);
20243 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
20244 if(!isWasmInitialized) {
20245 throw new Error("initializeWasm() must be awaited first!");
20247 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
20248 return nativeResponseValue;
20250 // 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);
20252 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
20253 if(!isWasmInitialized) {
20254 throw new Error("initializeWasm() must be awaited first!");
20256 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
20257 return nativeResponseValue;
20259 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
20261 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: number): void {
20262 if(!isWasmInitialized) {
20263 throw new Error("initializeWasm() must be awaited first!");
20265 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
20266 // debug statements here
20268 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
20270 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: number): void {
20271 if(!isWasmInitialized) {
20272 throw new Error("initializeWasm() must be awaited first!");
20274 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
20275 // debug statements here
20277 // 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);
20279 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
20280 if(!isWasmInitialized) {
20281 throw new Error("initializeWasm() must be awaited first!");
20283 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
20284 return nativeResponseValue;
20286 // 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);
20288 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
20289 if(!isWasmInitialized) {
20290 throw new Error("initializeWasm() must be awaited first!");
20292 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
20293 return nativeResponseValue;
20295 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
20297 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
20298 if(!isWasmInitialized) {
20299 throw new Error("initializeWasm() must be awaited first!");
20301 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
20302 // debug statements here
20304 // 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);
20306 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
20307 if(!isWasmInitialized) {
20308 throw new Error("initializeWasm() must be awaited first!");
20310 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
20311 return nativeResponseValue;
20313 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
20315 export function ChannelManager_send_probe(this_arg: number, hops: number): number {
20316 if(!isWasmInitialized) {
20317 throw new Error("initializeWasm() must be awaited first!");
20319 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
20320 return nativeResponseValue;
20322 // 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);
20324 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): number {
20325 if(!isWasmInitialized) {
20326 throw new Error("initializeWasm() must be awaited first!");
20328 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
20329 return nativeResponseValue;
20331 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
20333 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
20334 if(!isWasmInitialized) {
20335 throw new Error("initializeWasm() must be awaited first!");
20337 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
20338 // debug statements here
20340 // 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);
20342 export function ChannelManager_update_channel_config(this_arg: number, counterparty_node_id: number, channel_ids: number, config: number): number {
20343 if(!isWasmInitialized) {
20344 throw new Error("initializeWasm() must be awaited first!");
20346 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
20347 return nativeResponseValue;
20349 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
20351 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
20352 if(!isWasmInitialized) {
20353 throw new Error("initializeWasm() must be awaited first!");
20355 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
20356 // debug statements here
20358 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
20360 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
20361 if(!isWasmInitialized) {
20362 throw new Error("initializeWasm() must be awaited first!");
20364 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
20365 // debug statements here
20367 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
20369 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): void {
20370 if(!isWasmInitialized) {
20371 throw new Error("initializeWasm() must be awaited first!");
20373 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
20374 // debug statements here
20376 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
20378 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): void {
20379 if(!isWasmInitialized) {
20380 throw new Error("initializeWasm() must be awaited first!");
20382 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
20383 // debug statements here
20385 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
20387 export function ChannelManager_get_our_node_id(this_arg: number): number {
20388 if(!isWasmInitialized) {
20389 throw new Error("initializeWasm() must be awaited first!");
20391 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
20392 return nativeResponseValue;
20394 // 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);
20396 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
20397 if(!isWasmInitialized) {
20398 throw new Error("initializeWasm() must be awaited first!");
20400 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
20401 return nativeResponseValue;
20403 // 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);
20405 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
20406 if(!isWasmInitialized) {
20407 throw new Error("initializeWasm() must be awaited first!");
20409 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
20410 return nativeResponseValue;
20412 // 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);
20414 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20415 if(!isWasmInitialized) {
20416 throw new Error("initializeWasm() must be awaited first!");
20418 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
20419 return nativeResponseValue;
20421 // 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);
20423 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20424 if(!isWasmInitialized) {
20425 throw new Error("initializeWasm() must be awaited first!");
20427 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
20428 return nativeResponseValue;
20430 // 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);
20432 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20433 if(!isWasmInitialized) {
20434 throw new Error("initializeWasm() must be awaited first!");
20436 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
20437 return nativeResponseValue;
20439 // 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);
20441 export function ChannelManager_create_inbound_payment_for_hash_legacy(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20442 if(!isWasmInitialized) {
20443 throw new Error("initializeWasm() must be awaited first!");
20445 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
20446 return nativeResponseValue;
20448 // 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);
20450 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
20451 if(!isWasmInitialized) {
20452 throw new Error("initializeWasm() must be awaited first!");
20454 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
20455 return nativeResponseValue;
20457 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
20459 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
20460 if(!isWasmInitialized) {
20461 throw new Error("initializeWasm() must be awaited first!");
20463 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
20464 return nativeResponseValue;
20466 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
20468 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
20469 if(!isWasmInitialized) {
20470 throw new Error("initializeWasm() must be awaited first!");
20472 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
20473 return nativeResponseValue;
20475 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
20477 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
20478 if(!isWasmInitialized) {
20479 throw new Error("initializeWasm() must be awaited first!");
20481 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
20482 return nativeResponseValue;
20484 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
20486 export function ChannelManager_as_EventsProvider(this_arg: number): number {
20487 if(!isWasmInitialized) {
20488 throw new Error("initializeWasm() must be awaited first!");
20490 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
20491 return nativeResponseValue;
20493 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
20495 export function ChannelManager_as_Listen(this_arg: number): number {
20496 if(!isWasmInitialized) {
20497 throw new Error("initializeWasm() must be awaited first!");
20499 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
20500 return nativeResponseValue;
20502 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
20504 export function ChannelManager_as_Confirm(this_arg: number): number {
20505 if(!isWasmInitialized) {
20506 throw new Error("initializeWasm() must be awaited first!");
20508 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
20509 return nativeResponseValue;
20511 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
20513 export function ChannelManager_await_persistable_update(this_arg: number): void {
20514 if(!isWasmInitialized) {
20515 throw new Error("initializeWasm() must be awaited first!");
20517 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
20518 // debug statements here
20520 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
20522 export function ChannelManager_current_best_block(this_arg: number): number {
20523 if(!isWasmInitialized) {
20524 throw new Error("initializeWasm() must be awaited first!");
20526 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
20527 return nativeResponseValue;
20529 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
20531 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
20532 if(!isWasmInitialized) {
20533 throw new Error("initializeWasm() must be awaited first!");
20535 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
20536 return nativeResponseValue;
20538 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
20540 export function CounterpartyForwardingInfo_write(obj: number): number {
20541 if(!isWasmInitialized) {
20542 throw new Error("initializeWasm() must be awaited first!");
20544 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
20545 return nativeResponseValue;
20547 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
20549 export function CounterpartyForwardingInfo_read(ser: number): number {
20550 if(!isWasmInitialized) {
20551 throw new Error("initializeWasm() must be awaited first!");
20553 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
20554 return nativeResponseValue;
20556 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
20558 export function ChannelCounterparty_write(obj: number): number {
20559 if(!isWasmInitialized) {
20560 throw new Error("initializeWasm() must be awaited first!");
20562 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
20563 return nativeResponseValue;
20565 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
20567 export function ChannelCounterparty_read(ser: number): number {
20568 if(!isWasmInitialized) {
20569 throw new Error("initializeWasm() must be awaited first!");
20571 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
20572 return nativeResponseValue;
20574 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
20576 export function ChannelDetails_write(obj: number): number {
20577 if(!isWasmInitialized) {
20578 throw new Error("initializeWasm() must be awaited first!");
20580 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
20581 return nativeResponseValue;
20583 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
20585 export function ChannelDetails_read(ser: number): number {
20586 if(!isWasmInitialized) {
20587 throw new Error("initializeWasm() must be awaited first!");
20589 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
20590 return nativeResponseValue;
20592 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
20594 export function PhantomRouteHints_write(obj: number): number {
20595 if(!isWasmInitialized) {
20596 throw new Error("initializeWasm() must be awaited first!");
20598 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
20599 return nativeResponseValue;
20601 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
20603 export function PhantomRouteHints_read(ser: number): number {
20604 if(!isWasmInitialized) {
20605 throw new Error("initializeWasm() must be awaited first!");
20607 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
20608 return nativeResponseValue;
20610 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
20612 export function ChannelManager_write(obj: number): number {
20613 if(!isWasmInitialized) {
20614 throw new Error("initializeWasm() must be awaited first!");
20616 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
20617 return nativeResponseValue;
20619 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
20621 export function ChannelManagerReadArgs_free(this_obj: number): void {
20622 if(!isWasmInitialized) {
20623 throw new Error("initializeWasm() must be awaited first!");
20625 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
20626 // debug statements here
20628 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20630 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
20631 if(!isWasmInitialized) {
20632 throw new Error("initializeWasm() must be awaited first!");
20634 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
20635 return nativeResponseValue;
20637 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
20639 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
20640 if(!isWasmInitialized) {
20641 throw new Error("initializeWasm() must be awaited first!");
20643 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
20644 // debug statements here
20646 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20648 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
20649 if(!isWasmInitialized) {
20650 throw new Error("initializeWasm() must be awaited first!");
20652 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
20653 return nativeResponseValue;
20655 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
20657 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
20658 if(!isWasmInitialized) {
20659 throw new Error("initializeWasm() must be awaited first!");
20661 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
20662 // debug statements here
20664 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20666 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
20667 if(!isWasmInitialized) {
20668 throw new Error("initializeWasm() must be awaited first!");
20670 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
20671 return nativeResponseValue;
20673 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
20675 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
20676 if(!isWasmInitialized) {
20677 throw new Error("initializeWasm() must be awaited first!");
20679 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
20680 // debug statements here
20682 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20684 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
20685 if(!isWasmInitialized) {
20686 throw new Error("initializeWasm() must be awaited first!");
20688 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
20689 return nativeResponseValue;
20691 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
20693 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
20694 if(!isWasmInitialized) {
20695 throw new Error("initializeWasm() must be awaited first!");
20697 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
20698 // debug statements here
20700 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20702 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
20703 if(!isWasmInitialized) {
20704 throw new Error("initializeWasm() must be awaited first!");
20706 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
20707 return nativeResponseValue;
20709 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
20711 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
20712 if(!isWasmInitialized) {
20713 throw new Error("initializeWasm() must be awaited first!");
20715 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
20716 // debug statements here
20718 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20720 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
20721 if(!isWasmInitialized) {
20722 throw new Error("initializeWasm() must be awaited first!");
20724 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
20725 return nativeResponseValue;
20727 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
20729 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
20730 if(!isWasmInitialized) {
20731 throw new Error("initializeWasm() must be awaited first!");
20733 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
20734 // debug statements here
20736 // 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);
20738 export function ChannelManagerReadArgs_new(keys_manager: number, fee_estimator: number, chain_monitor: number, tx_broadcaster: number, logger: number, default_config: number, channel_monitors: number): number {
20739 if(!isWasmInitialized) {
20740 throw new Error("initializeWasm() must be awaited first!");
20742 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
20743 return nativeResponseValue;
20745 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
20747 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
20748 if(!isWasmInitialized) {
20749 throw new Error("initializeWasm() must be awaited first!");
20751 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
20752 return nativeResponseValue;
20754 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
20756 export function ExpandedKey_free(this_obj: number): void {
20757 if(!isWasmInitialized) {
20758 throw new Error("initializeWasm() must be awaited first!");
20760 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
20761 // debug statements here
20763 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
20765 export function ExpandedKey_new(key_material: number): number {
20766 if(!isWasmInitialized) {
20767 throw new Error("initializeWasm() must be awaited first!");
20769 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
20770 return nativeResponseValue;
20772 // 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);
20774 export function create(keys: number, min_value_msat: number, invoice_expiry_delta_secs: number, keys_manager: number, current_time: bigint): number {
20775 if(!isWasmInitialized) {
20776 throw new Error("initializeWasm() must be awaited first!");
20778 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
20779 return nativeResponseValue;
20781 // 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);
20783 export function create_from_hash(keys: number, min_value_msat: number, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): number {
20784 if(!isWasmInitialized) {
20785 throw new Error("initializeWasm() must be awaited first!");
20787 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20788 return nativeResponseValue;
20790 // void DecodeError_free(struct LDKDecodeError this_obj);
20792 export function DecodeError_free(this_obj: number): void {
20793 if(!isWasmInitialized) {
20794 throw new Error("initializeWasm() must be awaited first!");
20796 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20797 // debug statements here
20799 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20801 export function DecodeError_clone_ptr(arg: number): number {
20802 if(!isWasmInitialized) {
20803 throw new Error("initializeWasm() must be awaited first!");
20805 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20806 return nativeResponseValue;
20808 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20810 export function DecodeError_clone(orig: number): number {
20811 if(!isWasmInitialized) {
20812 throw new Error("initializeWasm() must be awaited first!");
20814 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20815 return nativeResponseValue;
20817 // void Init_free(struct LDKInit this_obj);
20819 export function Init_free(this_obj: number): void {
20820 if(!isWasmInitialized) {
20821 throw new Error("initializeWasm() must be awaited first!");
20823 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20824 // debug statements here
20826 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20828 export function Init_get_features(this_ptr: number): number {
20829 if(!isWasmInitialized) {
20830 throw new Error("initializeWasm() must be awaited first!");
20832 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20833 return nativeResponseValue;
20835 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20837 export function Init_set_features(this_ptr: number, val: number): void {
20838 if(!isWasmInitialized) {
20839 throw new Error("initializeWasm() must be awaited first!");
20841 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20842 // debug statements here
20844 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20846 export function Init_get_remote_network_address(this_ptr: number): number {
20847 if(!isWasmInitialized) {
20848 throw new Error("initializeWasm() must be awaited first!");
20850 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20851 return nativeResponseValue;
20853 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20855 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
20856 if(!isWasmInitialized) {
20857 throw new Error("initializeWasm() must be awaited first!");
20859 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20860 // debug statements here
20862 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20864 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
20865 if(!isWasmInitialized) {
20866 throw new Error("initializeWasm() must be awaited first!");
20868 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20869 return nativeResponseValue;
20871 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20873 export function Init_clone_ptr(arg: number): number {
20874 if(!isWasmInitialized) {
20875 throw new Error("initializeWasm() must be awaited first!");
20877 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20878 return nativeResponseValue;
20880 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20882 export function Init_clone(orig: number): number {
20883 if(!isWasmInitialized) {
20884 throw new Error("initializeWasm() must be awaited first!");
20886 const nativeResponseValue = wasm.TS_Init_clone(orig);
20887 return nativeResponseValue;
20889 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20891 export function ErrorMessage_free(this_obj: number): void {
20892 if(!isWasmInitialized) {
20893 throw new Error("initializeWasm() must be awaited first!");
20895 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20896 // debug statements here
20898 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20900 export function ErrorMessage_get_channel_id(this_ptr: number): number {
20901 if(!isWasmInitialized) {
20902 throw new Error("initializeWasm() must be awaited first!");
20904 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20905 return nativeResponseValue;
20907 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20909 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
20910 if(!isWasmInitialized) {
20911 throw new Error("initializeWasm() must be awaited first!");
20913 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20914 // debug statements here
20916 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20918 export function ErrorMessage_get_data(this_ptr: number): number {
20919 if(!isWasmInitialized) {
20920 throw new Error("initializeWasm() must be awaited first!");
20922 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20923 return nativeResponseValue;
20925 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20927 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
20928 if(!isWasmInitialized) {
20929 throw new Error("initializeWasm() must be awaited first!");
20931 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20932 // debug statements here
20934 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20936 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
20937 if(!isWasmInitialized) {
20938 throw new Error("initializeWasm() must be awaited first!");
20940 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20941 return nativeResponseValue;
20943 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20945 export function ErrorMessage_clone_ptr(arg: number): number {
20946 if(!isWasmInitialized) {
20947 throw new Error("initializeWasm() must be awaited first!");
20949 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20950 return nativeResponseValue;
20952 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20954 export function ErrorMessage_clone(orig: number): number {
20955 if(!isWasmInitialized) {
20956 throw new Error("initializeWasm() must be awaited first!");
20958 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20959 return nativeResponseValue;
20961 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20963 export function WarningMessage_free(this_obj: number): void {
20964 if(!isWasmInitialized) {
20965 throw new Error("initializeWasm() must be awaited first!");
20967 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20968 // debug statements here
20970 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20972 export function WarningMessage_get_channel_id(this_ptr: number): number {
20973 if(!isWasmInitialized) {
20974 throw new Error("initializeWasm() must be awaited first!");
20976 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20977 return nativeResponseValue;
20979 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20981 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
20982 if(!isWasmInitialized) {
20983 throw new Error("initializeWasm() must be awaited first!");
20985 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20986 // debug statements here
20988 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20990 export function WarningMessage_get_data(this_ptr: number): number {
20991 if(!isWasmInitialized) {
20992 throw new Error("initializeWasm() must be awaited first!");
20994 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
20995 return nativeResponseValue;
20997 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20999 export function WarningMessage_set_data(this_ptr: number, val: number): void {
21000 if(!isWasmInitialized) {
21001 throw new Error("initializeWasm() must be awaited first!");
21003 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
21004 // debug statements here
21006 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
21008 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
21009 if(!isWasmInitialized) {
21010 throw new Error("initializeWasm() must be awaited first!");
21012 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
21013 return nativeResponseValue;
21015 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
21017 export function WarningMessage_clone_ptr(arg: number): number {
21018 if(!isWasmInitialized) {
21019 throw new Error("initializeWasm() must be awaited first!");
21021 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
21022 return nativeResponseValue;
21024 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
21026 export function WarningMessage_clone(orig: number): number {
21027 if(!isWasmInitialized) {
21028 throw new Error("initializeWasm() must be awaited first!");
21030 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
21031 return nativeResponseValue;
21033 // void Ping_free(struct LDKPing this_obj);
21035 export function Ping_free(this_obj: number): void {
21036 if(!isWasmInitialized) {
21037 throw new Error("initializeWasm() must be awaited first!");
21039 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
21040 // debug statements here
21042 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
21044 export function Ping_get_ponglen(this_ptr: number): number {
21045 if(!isWasmInitialized) {
21046 throw new Error("initializeWasm() must be awaited first!");
21048 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
21049 return nativeResponseValue;
21051 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
21053 export function Ping_set_ponglen(this_ptr: number, val: number): void {
21054 if(!isWasmInitialized) {
21055 throw new Error("initializeWasm() must be awaited first!");
21057 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
21058 // debug statements here
21060 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
21062 export function Ping_get_byteslen(this_ptr: number): number {
21063 if(!isWasmInitialized) {
21064 throw new Error("initializeWasm() must be awaited first!");
21066 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
21067 return nativeResponseValue;
21069 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
21071 export function Ping_set_byteslen(this_ptr: number, val: number): void {
21072 if(!isWasmInitialized) {
21073 throw new Error("initializeWasm() must be awaited first!");
21075 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
21076 // debug statements here
21078 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
21080 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
21081 if(!isWasmInitialized) {
21082 throw new Error("initializeWasm() must be awaited first!");
21084 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
21085 return nativeResponseValue;
21087 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
21089 export function Ping_clone_ptr(arg: number): number {
21090 if(!isWasmInitialized) {
21091 throw new Error("initializeWasm() must be awaited first!");
21093 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
21094 return nativeResponseValue;
21096 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
21098 export function Ping_clone(orig: number): number {
21099 if(!isWasmInitialized) {
21100 throw new Error("initializeWasm() must be awaited first!");
21102 const nativeResponseValue = wasm.TS_Ping_clone(orig);
21103 return nativeResponseValue;
21105 // void Pong_free(struct LDKPong this_obj);
21107 export function Pong_free(this_obj: number): void {
21108 if(!isWasmInitialized) {
21109 throw new Error("initializeWasm() must be awaited first!");
21111 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
21112 // debug statements here
21114 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
21116 export function Pong_get_byteslen(this_ptr: number): number {
21117 if(!isWasmInitialized) {
21118 throw new Error("initializeWasm() must be awaited first!");
21120 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
21121 return nativeResponseValue;
21123 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
21125 export function Pong_set_byteslen(this_ptr: number, val: number): void {
21126 if(!isWasmInitialized) {
21127 throw new Error("initializeWasm() must be awaited first!");
21129 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
21130 // debug statements here
21132 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
21134 export function Pong_new(byteslen_arg: number): number {
21135 if(!isWasmInitialized) {
21136 throw new Error("initializeWasm() must be awaited first!");
21138 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
21139 return nativeResponseValue;
21141 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
21143 export function Pong_clone_ptr(arg: number): number {
21144 if(!isWasmInitialized) {
21145 throw new Error("initializeWasm() must be awaited first!");
21147 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
21148 return nativeResponseValue;
21150 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
21152 export function Pong_clone(orig: number): number {
21153 if(!isWasmInitialized) {
21154 throw new Error("initializeWasm() must be awaited first!");
21156 const nativeResponseValue = wasm.TS_Pong_clone(orig);
21157 return nativeResponseValue;
21159 // void OpenChannel_free(struct LDKOpenChannel this_obj);
21161 export function OpenChannel_free(this_obj: number): void {
21162 if(!isWasmInitialized) {
21163 throw new Error("initializeWasm() must be awaited first!");
21165 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
21166 // debug statements here
21168 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
21170 export function OpenChannel_get_chain_hash(this_ptr: number): number {
21171 if(!isWasmInitialized) {
21172 throw new Error("initializeWasm() must be awaited first!");
21174 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
21175 return nativeResponseValue;
21177 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21179 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
21180 if(!isWasmInitialized) {
21181 throw new Error("initializeWasm() must be awaited first!");
21183 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
21184 // debug statements here
21186 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
21188 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
21189 if(!isWasmInitialized) {
21190 throw new Error("initializeWasm() must be awaited first!");
21192 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
21193 return nativeResponseValue;
21195 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21197 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
21198 if(!isWasmInitialized) {
21199 throw new Error("initializeWasm() must be awaited first!");
21201 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
21202 // debug statements here
21204 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21206 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
21207 if(!isWasmInitialized) {
21208 throw new Error("initializeWasm() must be awaited first!");
21210 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
21211 return nativeResponseValue;
21213 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21215 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
21216 if(!isWasmInitialized) {
21217 throw new Error("initializeWasm() must be awaited first!");
21219 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
21220 // debug statements here
21222 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21224 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
21225 if(!isWasmInitialized) {
21226 throw new Error("initializeWasm() must be awaited first!");
21228 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
21229 return nativeResponseValue;
21231 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21233 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
21234 if(!isWasmInitialized) {
21235 throw new Error("initializeWasm() must be awaited first!");
21237 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
21238 // debug statements here
21240 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21242 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
21243 if(!isWasmInitialized) {
21244 throw new Error("initializeWasm() must be awaited first!");
21246 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
21247 return nativeResponseValue;
21249 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21251 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
21252 if(!isWasmInitialized) {
21253 throw new Error("initializeWasm() must be awaited first!");
21255 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
21256 // debug statements here
21258 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21260 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
21261 if(!isWasmInitialized) {
21262 throw new Error("initializeWasm() must be awaited first!");
21264 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21265 return nativeResponseValue;
21267 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21269 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
21270 if(!isWasmInitialized) {
21271 throw new Error("initializeWasm() must be awaited first!");
21273 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21274 // debug statements here
21276 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21278 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
21279 if(!isWasmInitialized) {
21280 throw new Error("initializeWasm() must be awaited first!");
21282 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
21283 return nativeResponseValue;
21285 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21287 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
21288 if(!isWasmInitialized) {
21289 throw new Error("initializeWasm() must be awaited first!");
21291 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
21292 // debug statements here
21294 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21296 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
21297 if(!isWasmInitialized) {
21298 throw new Error("initializeWasm() must be awaited first!");
21300 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
21301 return nativeResponseValue;
21303 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21305 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
21306 if(!isWasmInitialized) {
21307 throw new Error("initializeWasm() must be awaited first!");
21309 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
21310 // debug statements here
21312 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21314 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
21315 if(!isWasmInitialized) {
21316 throw new Error("initializeWasm() must be awaited first!");
21318 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
21319 return nativeResponseValue;
21321 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
21323 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
21324 if(!isWasmInitialized) {
21325 throw new Error("initializeWasm() must be awaited first!");
21327 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
21328 // debug statements here
21330 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21332 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
21333 if(!isWasmInitialized) {
21334 throw new Error("initializeWasm() must be awaited first!");
21336 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
21337 return nativeResponseValue;
21339 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
21341 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
21342 if(!isWasmInitialized) {
21343 throw new Error("initializeWasm() must be awaited first!");
21345 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
21346 // debug statements here
21348 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21350 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
21351 if(!isWasmInitialized) {
21352 throw new Error("initializeWasm() must be awaited first!");
21354 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
21355 return nativeResponseValue;
21357 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
21359 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
21360 if(!isWasmInitialized) {
21361 throw new Error("initializeWasm() must be awaited first!");
21363 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
21364 // debug statements here
21366 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21368 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
21369 if(!isWasmInitialized) {
21370 throw new Error("initializeWasm() must be awaited first!");
21372 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
21373 return nativeResponseValue;
21375 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21377 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
21378 if(!isWasmInitialized) {
21379 throw new Error("initializeWasm() must be awaited first!");
21381 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
21382 // debug statements here
21384 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21386 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
21387 if(!isWasmInitialized) {
21388 throw new Error("initializeWasm() must be awaited first!");
21390 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
21391 return nativeResponseValue;
21393 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21395 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
21396 if(!isWasmInitialized) {
21397 throw new Error("initializeWasm() must be awaited first!");
21399 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
21400 // debug statements here
21402 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21404 export function OpenChannel_get_payment_point(this_ptr: number): number {
21405 if(!isWasmInitialized) {
21406 throw new Error("initializeWasm() must be awaited first!");
21408 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
21409 return nativeResponseValue;
21411 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21413 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
21414 if(!isWasmInitialized) {
21415 throw new Error("initializeWasm() must be awaited first!");
21417 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
21418 // debug statements here
21420 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21422 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
21423 if(!isWasmInitialized) {
21424 throw new Error("initializeWasm() must be awaited first!");
21426 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
21427 return nativeResponseValue;
21429 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21431 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21432 if(!isWasmInitialized) {
21433 throw new Error("initializeWasm() must be awaited first!");
21435 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
21436 // debug statements here
21438 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21440 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
21441 if(!isWasmInitialized) {
21442 throw new Error("initializeWasm() must be awaited first!");
21444 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
21445 return nativeResponseValue;
21447 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21449 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
21450 if(!isWasmInitialized) {
21451 throw new Error("initializeWasm() must be awaited first!");
21453 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
21454 // debug statements here
21456 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21458 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
21459 if(!isWasmInitialized) {
21460 throw new Error("initializeWasm() must be awaited first!");
21462 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
21463 return nativeResponseValue;
21465 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21467 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21468 if(!isWasmInitialized) {
21469 throw new Error("initializeWasm() must be awaited first!");
21471 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
21472 // debug statements here
21474 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21476 export function OpenChannel_get_channel_flags(this_ptr: number): number {
21477 if(!isWasmInitialized) {
21478 throw new Error("initializeWasm() must be awaited first!");
21480 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
21481 return nativeResponseValue;
21483 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
21485 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
21486 if(!isWasmInitialized) {
21487 throw new Error("initializeWasm() must be awaited first!");
21489 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
21490 // debug statements here
21492 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21494 export function OpenChannel_get_channel_type(this_ptr: number): number {
21495 if(!isWasmInitialized) {
21496 throw new Error("initializeWasm() must be awaited first!");
21498 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
21499 return nativeResponseValue;
21501 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21503 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
21504 if(!isWasmInitialized) {
21505 throw new Error("initializeWasm() must be awaited first!");
21507 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
21508 // debug statements here
21510 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
21512 export function OpenChannel_clone_ptr(arg: number): number {
21513 if(!isWasmInitialized) {
21514 throw new Error("initializeWasm() must be awaited first!");
21516 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
21517 return nativeResponseValue;
21519 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
21521 export function OpenChannel_clone(orig: number): number {
21522 if(!isWasmInitialized) {
21523 throw new Error("initializeWasm() must be awaited first!");
21525 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
21526 return nativeResponseValue;
21528 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
21530 export function AcceptChannel_free(this_obj: number): void {
21531 if(!isWasmInitialized) {
21532 throw new Error("initializeWasm() must be awaited first!");
21534 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
21535 // debug statements here
21537 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
21539 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
21540 if(!isWasmInitialized) {
21541 throw new Error("initializeWasm() must be awaited first!");
21543 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
21544 return nativeResponseValue;
21546 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21548 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
21549 if(!isWasmInitialized) {
21550 throw new Error("initializeWasm() must be awaited first!");
21552 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
21553 // debug statements here
21555 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21557 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
21558 if(!isWasmInitialized) {
21559 throw new Error("initializeWasm() must be awaited first!");
21561 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
21562 return nativeResponseValue;
21564 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21566 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
21567 if(!isWasmInitialized) {
21568 throw new Error("initializeWasm() must be awaited first!");
21570 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
21571 // debug statements here
21573 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21575 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
21576 if(!isWasmInitialized) {
21577 throw new Error("initializeWasm() must be awaited first!");
21579 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21580 return nativeResponseValue;
21582 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21584 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
21585 if(!isWasmInitialized) {
21586 throw new Error("initializeWasm() must be awaited first!");
21588 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21589 // debug statements here
21591 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21593 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
21594 if(!isWasmInitialized) {
21595 throw new Error("initializeWasm() must be awaited first!");
21597 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
21598 return nativeResponseValue;
21600 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21602 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
21603 if(!isWasmInitialized) {
21604 throw new Error("initializeWasm() must be awaited first!");
21606 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
21607 // debug statements here
21609 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21611 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
21612 if(!isWasmInitialized) {
21613 throw new Error("initializeWasm() must be awaited first!");
21615 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
21616 return nativeResponseValue;
21618 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21620 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
21621 if(!isWasmInitialized) {
21622 throw new Error("initializeWasm() must be awaited first!");
21624 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
21625 // debug statements here
21627 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21629 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
21630 if(!isWasmInitialized) {
21631 throw new Error("initializeWasm() must be awaited first!");
21633 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
21634 return nativeResponseValue;
21636 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
21638 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
21639 if(!isWasmInitialized) {
21640 throw new Error("initializeWasm() must be awaited first!");
21642 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
21643 // debug statements here
21645 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21647 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
21648 if(!isWasmInitialized) {
21649 throw new Error("initializeWasm() must be awaited first!");
21651 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
21652 return nativeResponseValue;
21654 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21656 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
21657 if(!isWasmInitialized) {
21658 throw new Error("initializeWasm() must be awaited first!");
21660 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
21661 // debug statements here
21663 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21665 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
21666 if(!isWasmInitialized) {
21667 throw new Error("initializeWasm() must be awaited first!");
21669 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
21670 return nativeResponseValue;
21672 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21674 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
21675 if(!isWasmInitialized) {
21676 throw new Error("initializeWasm() must be awaited first!");
21678 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
21679 // debug statements here
21681 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21683 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
21684 if(!isWasmInitialized) {
21685 throw new Error("initializeWasm() must be awaited first!");
21687 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
21688 return nativeResponseValue;
21690 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21692 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
21693 if(!isWasmInitialized) {
21694 throw new Error("initializeWasm() must be awaited first!");
21696 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
21697 // debug statements here
21699 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21701 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
21702 if(!isWasmInitialized) {
21703 throw new Error("initializeWasm() must be awaited first!");
21705 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
21706 return nativeResponseValue;
21708 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21710 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
21711 if(!isWasmInitialized) {
21712 throw new Error("initializeWasm() must be awaited first!");
21714 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
21715 // debug statements here
21717 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21719 export function AcceptChannel_get_payment_point(this_ptr: number): number {
21720 if(!isWasmInitialized) {
21721 throw new Error("initializeWasm() must be awaited first!");
21723 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
21724 return nativeResponseValue;
21726 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21728 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
21729 if(!isWasmInitialized) {
21730 throw new Error("initializeWasm() must be awaited first!");
21732 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
21733 // debug statements here
21735 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21737 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
21738 if(!isWasmInitialized) {
21739 throw new Error("initializeWasm() must be awaited first!");
21741 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
21742 return nativeResponseValue;
21744 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21746 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21747 if(!isWasmInitialized) {
21748 throw new Error("initializeWasm() must be awaited first!");
21750 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
21751 // debug statements here
21753 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21755 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
21756 if(!isWasmInitialized) {
21757 throw new Error("initializeWasm() must be awaited first!");
21759 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
21760 return nativeResponseValue;
21762 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21764 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
21765 if(!isWasmInitialized) {
21766 throw new Error("initializeWasm() must be awaited first!");
21768 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
21769 // debug statements here
21771 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21773 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
21774 if(!isWasmInitialized) {
21775 throw new Error("initializeWasm() must be awaited first!");
21777 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
21778 return nativeResponseValue;
21780 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21782 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21783 if(!isWasmInitialized) {
21784 throw new Error("initializeWasm() must be awaited first!");
21786 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21787 // debug statements here
21789 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21791 export function AcceptChannel_get_channel_type(this_ptr: number): number {
21792 if(!isWasmInitialized) {
21793 throw new Error("initializeWasm() must be awaited first!");
21795 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21796 return nativeResponseValue;
21798 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21800 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
21801 if(!isWasmInitialized) {
21802 throw new Error("initializeWasm() must be awaited first!");
21804 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21805 // debug statements here
21807 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21809 export function AcceptChannel_clone_ptr(arg: number): number {
21810 if(!isWasmInitialized) {
21811 throw new Error("initializeWasm() must be awaited first!");
21813 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21814 return nativeResponseValue;
21816 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21818 export function AcceptChannel_clone(orig: number): number {
21819 if(!isWasmInitialized) {
21820 throw new Error("initializeWasm() must be awaited first!");
21822 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21823 return nativeResponseValue;
21825 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21827 export function FundingCreated_free(this_obj: number): void {
21828 if(!isWasmInitialized) {
21829 throw new Error("initializeWasm() must be awaited first!");
21831 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21832 // debug statements here
21834 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21836 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
21837 if(!isWasmInitialized) {
21838 throw new Error("initializeWasm() must be awaited first!");
21840 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21841 return nativeResponseValue;
21843 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21845 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
21846 if(!isWasmInitialized) {
21847 throw new Error("initializeWasm() must be awaited first!");
21849 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21850 // debug statements here
21852 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21854 export function FundingCreated_get_funding_txid(this_ptr: number): number {
21855 if(!isWasmInitialized) {
21856 throw new Error("initializeWasm() must be awaited first!");
21858 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21859 return nativeResponseValue;
21861 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21863 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
21864 if(!isWasmInitialized) {
21865 throw new Error("initializeWasm() must be awaited first!");
21867 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21868 // debug statements here
21870 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21872 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
21873 if(!isWasmInitialized) {
21874 throw new Error("initializeWasm() must be awaited first!");
21876 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21877 return nativeResponseValue;
21879 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21881 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
21882 if(!isWasmInitialized) {
21883 throw new Error("initializeWasm() must be awaited first!");
21885 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21886 // debug statements here
21888 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21890 export function FundingCreated_get_signature(this_ptr: number): number {
21891 if(!isWasmInitialized) {
21892 throw new Error("initializeWasm() must be awaited first!");
21894 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21895 return nativeResponseValue;
21897 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21899 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
21900 if(!isWasmInitialized) {
21901 throw new Error("initializeWasm() must be awaited first!");
21903 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21904 // debug statements here
21906 // 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);
21908 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
21909 if(!isWasmInitialized) {
21910 throw new Error("initializeWasm() must be awaited first!");
21912 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21913 return nativeResponseValue;
21915 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21917 export function FundingCreated_clone_ptr(arg: number): number {
21918 if(!isWasmInitialized) {
21919 throw new Error("initializeWasm() must be awaited first!");
21921 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21922 return nativeResponseValue;
21924 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21926 export function FundingCreated_clone(orig: number): number {
21927 if(!isWasmInitialized) {
21928 throw new Error("initializeWasm() must be awaited first!");
21930 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21931 return nativeResponseValue;
21933 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21935 export function FundingSigned_free(this_obj: number): void {
21936 if(!isWasmInitialized) {
21937 throw new Error("initializeWasm() must be awaited first!");
21939 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21940 // debug statements here
21942 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21944 export function FundingSigned_get_channel_id(this_ptr: number): number {
21945 if(!isWasmInitialized) {
21946 throw new Error("initializeWasm() must be awaited first!");
21948 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21949 return nativeResponseValue;
21951 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21953 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
21954 if(!isWasmInitialized) {
21955 throw new Error("initializeWasm() must be awaited first!");
21957 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21958 // debug statements here
21960 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21962 export function FundingSigned_get_signature(this_ptr: number): number {
21963 if(!isWasmInitialized) {
21964 throw new Error("initializeWasm() must be awaited first!");
21966 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21967 return nativeResponseValue;
21969 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21971 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
21972 if(!isWasmInitialized) {
21973 throw new Error("initializeWasm() must be awaited first!");
21975 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21976 // debug statements here
21978 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21980 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
21981 if(!isWasmInitialized) {
21982 throw new Error("initializeWasm() must be awaited first!");
21984 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21985 return nativeResponseValue;
21987 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21989 export function FundingSigned_clone_ptr(arg: number): number {
21990 if(!isWasmInitialized) {
21991 throw new Error("initializeWasm() must be awaited first!");
21993 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
21994 return nativeResponseValue;
21996 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
21998 export function FundingSigned_clone(orig: number): number {
21999 if(!isWasmInitialized) {
22000 throw new Error("initializeWasm() must be awaited first!");
22002 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
22003 return nativeResponseValue;
22005 // void ChannelReady_free(struct LDKChannelReady this_obj);
22007 export function ChannelReady_free(this_obj: number): void {
22008 if(!isWasmInitialized) {
22009 throw new Error("initializeWasm() must be awaited first!");
22011 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
22012 // debug statements here
22014 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
22016 export function ChannelReady_get_channel_id(this_ptr: number): number {
22017 if(!isWasmInitialized) {
22018 throw new Error("initializeWasm() must be awaited first!");
22020 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
22021 return nativeResponseValue;
22023 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22025 export function ChannelReady_set_channel_id(this_ptr: number, val: number): void {
22026 if(!isWasmInitialized) {
22027 throw new Error("initializeWasm() must be awaited first!");
22029 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
22030 // debug statements here
22032 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
22034 export function ChannelReady_get_next_per_commitment_point(this_ptr: number): number {
22035 if(!isWasmInitialized) {
22036 throw new Error("initializeWasm() must be awaited first!");
22038 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
22039 return nativeResponseValue;
22041 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22043 export function ChannelReady_set_next_per_commitment_point(this_ptr: number, val: number): void {
22044 if(!isWasmInitialized) {
22045 throw new Error("initializeWasm() must be awaited first!");
22047 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
22048 // debug statements here
22050 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
22052 export function ChannelReady_get_short_channel_id_alias(this_ptr: number): number {
22053 if(!isWasmInitialized) {
22054 throw new Error("initializeWasm() must be awaited first!");
22056 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
22057 return nativeResponseValue;
22059 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22061 export function ChannelReady_set_short_channel_id_alias(this_ptr: number, val: number): void {
22062 if(!isWasmInitialized) {
22063 throw new Error("initializeWasm() must be awaited first!");
22065 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
22066 // debug statements here
22068 // 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);
22070 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
22071 if(!isWasmInitialized) {
22072 throw new Error("initializeWasm() must be awaited first!");
22074 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
22075 return nativeResponseValue;
22077 // uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
22079 export function ChannelReady_clone_ptr(arg: number): number {
22080 if(!isWasmInitialized) {
22081 throw new Error("initializeWasm() must be awaited first!");
22083 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
22084 return nativeResponseValue;
22086 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
22088 export function ChannelReady_clone(orig: number): number {
22089 if(!isWasmInitialized) {
22090 throw new Error("initializeWasm() must be awaited first!");
22092 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
22093 return nativeResponseValue;
22095 // void Shutdown_free(struct LDKShutdown this_obj);
22097 export function Shutdown_free(this_obj: number): void {
22098 if(!isWasmInitialized) {
22099 throw new Error("initializeWasm() must be awaited first!");
22101 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
22102 // debug statements here
22104 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
22106 export function Shutdown_get_channel_id(this_ptr: number): number {
22107 if(!isWasmInitialized) {
22108 throw new Error("initializeWasm() must be awaited first!");
22110 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
22111 return nativeResponseValue;
22113 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22115 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
22116 if(!isWasmInitialized) {
22117 throw new Error("initializeWasm() must be awaited first!");
22119 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
22120 // debug statements here
22122 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
22124 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
22125 if(!isWasmInitialized) {
22126 throw new Error("initializeWasm() must be awaited first!");
22128 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
22129 return nativeResponseValue;
22131 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
22133 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
22134 if(!isWasmInitialized) {
22135 throw new Error("initializeWasm() must be awaited first!");
22137 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
22138 // debug statements here
22140 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
22142 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
22143 if(!isWasmInitialized) {
22144 throw new Error("initializeWasm() must be awaited first!");
22146 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
22147 return nativeResponseValue;
22149 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
22151 export function Shutdown_clone_ptr(arg: number): number {
22152 if(!isWasmInitialized) {
22153 throw new Error("initializeWasm() must be awaited first!");
22155 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
22156 return nativeResponseValue;
22158 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
22160 export function Shutdown_clone(orig: number): number {
22161 if(!isWasmInitialized) {
22162 throw new Error("initializeWasm() must be awaited first!");
22164 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
22165 return nativeResponseValue;
22167 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
22169 export function ClosingSignedFeeRange_free(this_obj: number): void {
22170 if(!isWasmInitialized) {
22171 throw new Error("initializeWasm() must be awaited first!");
22173 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
22174 // debug statements here
22176 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
22178 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
22179 if(!isWasmInitialized) {
22180 throw new Error("initializeWasm() must be awaited first!");
22182 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
22183 return nativeResponseValue;
22185 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
22187 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
22188 if(!isWasmInitialized) {
22189 throw new Error("initializeWasm() must be awaited first!");
22191 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
22192 // debug statements here
22194 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
22196 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
22197 if(!isWasmInitialized) {
22198 throw new Error("initializeWasm() must be awaited first!");
22200 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
22201 return nativeResponseValue;
22203 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
22205 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
22206 if(!isWasmInitialized) {
22207 throw new Error("initializeWasm() must be awaited first!");
22209 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
22210 // debug statements here
22212 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
22214 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
22215 if(!isWasmInitialized) {
22216 throw new Error("initializeWasm() must be awaited first!");
22218 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
22219 return nativeResponseValue;
22221 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
22223 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
22224 if(!isWasmInitialized) {
22225 throw new Error("initializeWasm() must be awaited first!");
22227 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
22228 return nativeResponseValue;
22230 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
22232 export function ClosingSignedFeeRange_clone(orig: number): number {
22233 if(!isWasmInitialized) {
22234 throw new Error("initializeWasm() must be awaited first!");
22236 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
22237 return nativeResponseValue;
22239 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
22241 export function ClosingSigned_free(this_obj: number): void {
22242 if(!isWasmInitialized) {
22243 throw new Error("initializeWasm() must be awaited first!");
22245 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
22246 // debug statements here
22248 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
22250 export function ClosingSigned_get_channel_id(this_ptr: number): number {
22251 if(!isWasmInitialized) {
22252 throw new Error("initializeWasm() must be awaited first!");
22254 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
22255 return nativeResponseValue;
22257 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22259 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
22260 if(!isWasmInitialized) {
22261 throw new Error("initializeWasm() must be awaited first!");
22263 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
22264 // debug statements here
22266 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22268 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
22269 if(!isWasmInitialized) {
22270 throw new Error("initializeWasm() must be awaited first!");
22272 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
22273 return nativeResponseValue;
22275 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
22277 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
22278 if(!isWasmInitialized) {
22279 throw new Error("initializeWasm() must be awaited first!");
22281 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
22282 // debug statements here
22284 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22286 export function ClosingSigned_get_signature(this_ptr: number): number {
22287 if(!isWasmInitialized) {
22288 throw new Error("initializeWasm() must be awaited first!");
22290 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
22291 return nativeResponseValue;
22293 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22295 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
22296 if(!isWasmInitialized) {
22297 throw new Error("initializeWasm() must be awaited first!");
22299 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
22300 // debug statements here
22302 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22304 export function ClosingSigned_get_fee_range(this_ptr: number): number {
22305 if(!isWasmInitialized) {
22306 throw new Error("initializeWasm() must be awaited first!");
22308 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
22309 return nativeResponseValue;
22311 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
22313 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
22314 if(!isWasmInitialized) {
22315 throw new Error("initializeWasm() must be awaited first!");
22317 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
22318 // debug statements here
22320 // 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);
22322 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
22323 if(!isWasmInitialized) {
22324 throw new Error("initializeWasm() must be awaited first!");
22326 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
22327 return nativeResponseValue;
22329 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
22331 export function ClosingSigned_clone_ptr(arg: number): number {
22332 if(!isWasmInitialized) {
22333 throw new Error("initializeWasm() must be awaited first!");
22335 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
22336 return nativeResponseValue;
22338 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
22340 export function ClosingSigned_clone(orig: number): number {
22341 if(!isWasmInitialized) {
22342 throw new Error("initializeWasm() must be awaited first!");
22344 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
22345 return nativeResponseValue;
22347 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
22349 export function UpdateAddHTLC_free(this_obj: number): void {
22350 if(!isWasmInitialized) {
22351 throw new Error("initializeWasm() must be awaited first!");
22353 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
22354 // debug statements here
22356 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
22358 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
22359 if(!isWasmInitialized) {
22360 throw new Error("initializeWasm() must be awaited first!");
22362 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
22363 return nativeResponseValue;
22365 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22367 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
22368 if(!isWasmInitialized) {
22369 throw new Error("initializeWasm() must be awaited first!");
22371 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
22372 // debug statements here
22374 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22376 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
22377 if(!isWasmInitialized) {
22378 throw new Error("initializeWasm() must be awaited first!");
22380 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
22381 return nativeResponseValue;
22383 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
22385 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22386 if(!isWasmInitialized) {
22387 throw new Error("initializeWasm() must be awaited first!");
22389 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
22390 // debug statements here
22392 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22394 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
22395 if(!isWasmInitialized) {
22396 throw new Error("initializeWasm() must be awaited first!");
22398 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
22399 return nativeResponseValue;
22401 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
22403 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
22404 if(!isWasmInitialized) {
22405 throw new Error("initializeWasm() must be awaited first!");
22407 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
22408 // debug statements here
22410 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
22412 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
22413 if(!isWasmInitialized) {
22414 throw new Error("initializeWasm() must be awaited first!");
22416 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
22417 return nativeResponseValue;
22419 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22421 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
22422 if(!isWasmInitialized) {
22423 throw new Error("initializeWasm() must be awaited first!");
22425 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
22426 // debug statements here
22428 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22430 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
22431 if(!isWasmInitialized) {
22432 throw new Error("initializeWasm() must be awaited first!");
22434 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
22435 return nativeResponseValue;
22437 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
22439 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
22440 if(!isWasmInitialized) {
22441 throw new Error("initializeWasm() must be awaited first!");
22443 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
22444 // debug statements here
22446 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
22448 export function UpdateAddHTLC_clone_ptr(arg: number): number {
22449 if(!isWasmInitialized) {
22450 throw new Error("initializeWasm() must be awaited first!");
22452 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
22453 return nativeResponseValue;
22455 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
22457 export function UpdateAddHTLC_clone(orig: number): number {
22458 if(!isWasmInitialized) {
22459 throw new Error("initializeWasm() must be awaited first!");
22461 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
22462 return nativeResponseValue;
22464 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
22466 export function UpdateFulfillHTLC_free(this_obj: number): void {
22467 if(!isWasmInitialized) {
22468 throw new Error("initializeWasm() must be awaited first!");
22470 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
22471 // debug statements here
22473 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22475 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
22476 if(!isWasmInitialized) {
22477 throw new Error("initializeWasm() must be awaited first!");
22479 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
22480 return nativeResponseValue;
22482 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22484 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
22485 if(!isWasmInitialized) {
22486 throw new Error("initializeWasm() must be awaited first!");
22488 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
22489 // debug statements here
22491 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
22493 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
22494 if(!isWasmInitialized) {
22495 throw new Error("initializeWasm() must be awaited first!");
22497 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
22498 return nativeResponseValue;
22500 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
22502 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22503 if(!isWasmInitialized) {
22504 throw new Error("initializeWasm() must be awaited first!");
22506 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
22507 // debug statements here
22509 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22511 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
22512 if(!isWasmInitialized) {
22513 throw new Error("initializeWasm() must be awaited first!");
22515 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
22516 return nativeResponseValue;
22518 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22520 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
22521 if(!isWasmInitialized) {
22522 throw new Error("initializeWasm() must be awaited first!");
22524 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
22525 // debug statements here
22527 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
22529 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
22530 if(!isWasmInitialized) {
22531 throw new Error("initializeWasm() must be awaited first!");
22533 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
22534 return nativeResponseValue;
22536 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
22538 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
22539 if(!isWasmInitialized) {
22540 throw new Error("initializeWasm() must be awaited first!");
22542 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
22543 return nativeResponseValue;
22545 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
22547 export function UpdateFulfillHTLC_clone(orig: number): number {
22548 if(!isWasmInitialized) {
22549 throw new Error("initializeWasm() must be awaited first!");
22551 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
22552 return nativeResponseValue;
22554 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
22556 export function UpdateFailHTLC_free(this_obj: number): void {
22557 if(!isWasmInitialized) {
22558 throw new Error("initializeWasm() must be awaited first!");
22560 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
22561 // debug statements here
22563 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
22565 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
22566 if(!isWasmInitialized) {
22567 throw new Error("initializeWasm() must be awaited first!");
22569 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
22570 return nativeResponseValue;
22572 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22574 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
22575 if(!isWasmInitialized) {
22576 throw new Error("initializeWasm() must be awaited first!");
22578 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
22579 // debug statements here
22581 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
22583 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
22584 if(!isWasmInitialized) {
22585 throw new Error("initializeWasm() must be awaited first!");
22587 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
22588 return nativeResponseValue;
22590 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
22592 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22593 if(!isWasmInitialized) {
22594 throw new Error("initializeWasm() must be awaited first!");
22596 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
22597 // debug statements here
22599 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
22601 export function UpdateFailHTLC_clone_ptr(arg: number): number {
22602 if(!isWasmInitialized) {
22603 throw new Error("initializeWasm() must be awaited first!");
22605 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
22606 return nativeResponseValue;
22608 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
22610 export function UpdateFailHTLC_clone(orig: number): number {
22611 if(!isWasmInitialized) {
22612 throw new Error("initializeWasm() must be awaited first!");
22614 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
22615 return nativeResponseValue;
22617 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
22619 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
22620 if(!isWasmInitialized) {
22621 throw new Error("initializeWasm() must be awaited first!");
22623 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
22624 // debug statements here
22626 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
22628 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
22629 if(!isWasmInitialized) {
22630 throw new Error("initializeWasm() must be awaited first!");
22632 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
22633 return nativeResponseValue;
22635 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22637 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
22638 if(!isWasmInitialized) {
22639 throw new Error("initializeWasm() must be awaited first!");
22641 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
22642 // debug statements here
22644 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22646 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
22647 if(!isWasmInitialized) {
22648 throw new Error("initializeWasm() must be awaited first!");
22650 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
22651 return nativeResponseValue;
22653 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
22655 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22656 if(!isWasmInitialized) {
22657 throw new Error("initializeWasm() must be awaited first!");
22659 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
22660 // debug statements here
22662 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22664 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
22665 if(!isWasmInitialized) {
22666 throw new Error("initializeWasm() must be awaited first!");
22668 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
22669 return nativeResponseValue;
22671 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
22673 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
22674 if(!isWasmInitialized) {
22675 throw new Error("initializeWasm() must be awaited first!");
22677 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
22678 // debug statements here
22680 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
22682 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
22683 if(!isWasmInitialized) {
22684 throw new Error("initializeWasm() must be awaited first!");
22686 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
22687 return nativeResponseValue;
22689 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
22691 export function UpdateFailMalformedHTLC_clone(orig: number): number {
22692 if(!isWasmInitialized) {
22693 throw new Error("initializeWasm() must be awaited first!");
22695 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
22696 return nativeResponseValue;
22698 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
22700 export function CommitmentSigned_free(this_obj: number): void {
22701 if(!isWasmInitialized) {
22702 throw new Error("initializeWasm() must be awaited first!");
22704 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
22705 // debug statements here
22707 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
22709 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
22710 if(!isWasmInitialized) {
22711 throw new Error("initializeWasm() must be awaited first!");
22713 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
22714 return nativeResponseValue;
22716 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22718 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
22719 if(!isWasmInitialized) {
22720 throw new Error("initializeWasm() must be awaited first!");
22722 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
22723 // debug statements here
22725 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22727 export function CommitmentSigned_get_signature(this_ptr: number): number {
22728 if(!isWasmInitialized) {
22729 throw new Error("initializeWasm() must be awaited first!");
22731 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
22732 return nativeResponseValue;
22734 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22736 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
22737 if(!isWasmInitialized) {
22738 throw new Error("initializeWasm() must be awaited first!");
22740 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
22741 // debug statements here
22743 // struct LDKCVec_SignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22745 export function CommitmentSigned_get_htlc_signatures(this_ptr: number): number {
22746 if(!isWasmInitialized) {
22747 throw new Error("initializeWasm() must be awaited first!");
22749 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
22750 return nativeResponseValue;
22752 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22754 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
22755 if(!isWasmInitialized) {
22756 throw new Error("initializeWasm() must be awaited first!");
22758 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
22759 // debug statements here
22761 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
22763 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
22764 if(!isWasmInitialized) {
22765 throw new Error("initializeWasm() must be awaited first!");
22767 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
22768 return nativeResponseValue;
22770 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
22772 export function CommitmentSigned_clone_ptr(arg: number): number {
22773 if(!isWasmInitialized) {
22774 throw new Error("initializeWasm() must be awaited first!");
22776 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
22777 return nativeResponseValue;
22779 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
22781 export function CommitmentSigned_clone(orig: number): number {
22782 if(!isWasmInitialized) {
22783 throw new Error("initializeWasm() must be awaited first!");
22785 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
22786 return nativeResponseValue;
22788 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
22790 export function RevokeAndACK_free(this_obj: number): void {
22791 if(!isWasmInitialized) {
22792 throw new Error("initializeWasm() must be awaited first!");
22794 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22795 // debug statements here
22797 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22799 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
22800 if(!isWasmInitialized) {
22801 throw new Error("initializeWasm() must be awaited first!");
22803 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22804 return nativeResponseValue;
22806 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22808 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
22809 if(!isWasmInitialized) {
22810 throw new Error("initializeWasm() must be awaited first!");
22812 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22813 // debug statements here
22815 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22817 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
22818 if(!isWasmInitialized) {
22819 throw new Error("initializeWasm() must be awaited first!");
22821 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22822 return nativeResponseValue;
22824 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22826 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
22827 if(!isWasmInitialized) {
22828 throw new Error("initializeWasm() must be awaited first!");
22830 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22831 // debug statements here
22833 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22835 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
22836 if(!isWasmInitialized) {
22837 throw new Error("initializeWasm() must be awaited first!");
22839 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22840 return nativeResponseValue;
22842 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22844 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
22845 if(!isWasmInitialized) {
22846 throw new Error("initializeWasm() must be awaited first!");
22848 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22849 // debug statements here
22851 // 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);
22853 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
22854 if(!isWasmInitialized) {
22855 throw new Error("initializeWasm() must be awaited first!");
22857 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22858 return nativeResponseValue;
22860 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22862 export function RevokeAndACK_clone_ptr(arg: number): number {
22863 if(!isWasmInitialized) {
22864 throw new Error("initializeWasm() must be awaited first!");
22866 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22867 return nativeResponseValue;
22869 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22871 export function RevokeAndACK_clone(orig: number): number {
22872 if(!isWasmInitialized) {
22873 throw new Error("initializeWasm() must be awaited first!");
22875 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22876 return nativeResponseValue;
22878 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22880 export function UpdateFee_free(this_obj: number): void {
22881 if(!isWasmInitialized) {
22882 throw new Error("initializeWasm() must be awaited first!");
22884 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22885 // debug statements here
22887 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22889 export function UpdateFee_get_channel_id(this_ptr: number): number {
22890 if(!isWasmInitialized) {
22891 throw new Error("initializeWasm() must be awaited first!");
22893 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22894 return nativeResponseValue;
22896 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22898 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
22899 if(!isWasmInitialized) {
22900 throw new Error("initializeWasm() must be awaited first!");
22902 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22903 // debug statements here
22905 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22907 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
22908 if(!isWasmInitialized) {
22909 throw new Error("initializeWasm() must be awaited first!");
22911 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22912 return nativeResponseValue;
22914 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22916 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
22917 if(!isWasmInitialized) {
22918 throw new Error("initializeWasm() must be awaited first!");
22920 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22921 // debug statements here
22923 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22925 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
22926 if(!isWasmInitialized) {
22927 throw new Error("initializeWasm() must be awaited first!");
22929 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22930 return nativeResponseValue;
22932 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22934 export function UpdateFee_clone_ptr(arg: number): number {
22935 if(!isWasmInitialized) {
22936 throw new Error("initializeWasm() must be awaited first!");
22938 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22939 return nativeResponseValue;
22941 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22943 export function UpdateFee_clone(orig: number): number {
22944 if(!isWasmInitialized) {
22945 throw new Error("initializeWasm() must be awaited first!");
22947 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22948 return nativeResponseValue;
22950 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22952 export function DataLossProtect_free(this_obj: number): void {
22953 if(!isWasmInitialized) {
22954 throw new Error("initializeWasm() must be awaited first!");
22956 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22957 // debug statements here
22959 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22961 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
22962 if(!isWasmInitialized) {
22963 throw new Error("initializeWasm() must be awaited first!");
22965 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22966 return nativeResponseValue;
22968 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22970 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
22971 if(!isWasmInitialized) {
22972 throw new Error("initializeWasm() must be awaited first!");
22974 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22975 // debug statements here
22977 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22979 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
22980 if(!isWasmInitialized) {
22981 throw new Error("initializeWasm() must be awaited first!");
22983 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22984 return nativeResponseValue;
22986 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22988 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
22989 if(!isWasmInitialized) {
22990 throw new Error("initializeWasm() must be awaited first!");
22992 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
22993 // debug statements here
22995 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
22997 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
22998 if(!isWasmInitialized) {
22999 throw new Error("initializeWasm() must be awaited first!");
23001 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
23002 return nativeResponseValue;
23004 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
23006 export function DataLossProtect_clone_ptr(arg: number): number {
23007 if(!isWasmInitialized) {
23008 throw new Error("initializeWasm() must be awaited first!");
23010 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
23011 return nativeResponseValue;
23013 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
23015 export function DataLossProtect_clone(orig: number): number {
23016 if(!isWasmInitialized) {
23017 throw new Error("initializeWasm() must be awaited first!");
23019 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
23020 return nativeResponseValue;
23022 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
23024 export function ChannelReestablish_free(this_obj: number): void {
23025 if(!isWasmInitialized) {
23026 throw new Error("initializeWasm() must be awaited first!");
23028 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
23029 // debug statements here
23031 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
23033 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
23034 if(!isWasmInitialized) {
23035 throw new Error("initializeWasm() must be awaited first!");
23037 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
23038 return nativeResponseValue;
23040 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23042 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
23043 if(!isWasmInitialized) {
23044 throw new Error("initializeWasm() must be awaited first!");
23046 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
23047 // debug statements here
23049 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
23051 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
23052 if(!isWasmInitialized) {
23053 throw new Error("initializeWasm() must be awaited first!");
23055 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
23056 return nativeResponseValue;
23058 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
23060 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
23061 if(!isWasmInitialized) {
23062 throw new Error("initializeWasm() must be awaited first!");
23064 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
23065 // debug statements here
23067 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
23069 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
23070 if(!isWasmInitialized) {
23071 throw new Error("initializeWasm() must be awaited first!");
23073 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
23074 return nativeResponseValue;
23076 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
23078 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
23079 if(!isWasmInitialized) {
23080 throw new Error("initializeWasm() must be awaited first!");
23082 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
23083 // debug statements here
23085 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
23087 export function ChannelReestablish_clone_ptr(arg: number): number {
23088 if(!isWasmInitialized) {
23089 throw new Error("initializeWasm() must be awaited first!");
23091 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
23092 return nativeResponseValue;
23094 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
23096 export function ChannelReestablish_clone(orig: number): number {
23097 if(!isWasmInitialized) {
23098 throw new Error("initializeWasm() must be awaited first!");
23100 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
23101 return nativeResponseValue;
23103 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
23105 export function AnnouncementSignatures_free(this_obj: number): void {
23106 if(!isWasmInitialized) {
23107 throw new Error("initializeWasm() must be awaited first!");
23109 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
23110 // debug statements here
23112 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
23114 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
23115 if(!isWasmInitialized) {
23116 throw new Error("initializeWasm() must be awaited first!");
23118 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
23119 return nativeResponseValue;
23121 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23123 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
23124 if(!isWasmInitialized) {
23125 throw new Error("initializeWasm() must be awaited first!");
23127 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
23128 // debug statements here
23130 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23132 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
23133 if(!isWasmInitialized) {
23134 throw new Error("initializeWasm() must be awaited first!");
23136 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
23137 return nativeResponseValue;
23139 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
23141 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
23142 if(!isWasmInitialized) {
23143 throw new Error("initializeWasm() must be awaited first!");
23145 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
23146 // debug statements here
23148 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23150 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
23151 if(!isWasmInitialized) {
23152 throw new Error("initializeWasm() must be awaited first!");
23154 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
23155 return nativeResponseValue;
23157 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
23159 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
23160 if(!isWasmInitialized) {
23161 throw new Error("initializeWasm() must be awaited first!");
23163 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
23164 // debug statements here
23166 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23168 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
23169 if(!isWasmInitialized) {
23170 throw new Error("initializeWasm() must be awaited first!");
23172 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
23173 return nativeResponseValue;
23175 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
23177 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
23178 if(!isWasmInitialized) {
23179 throw new Error("initializeWasm() must be awaited first!");
23181 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
23182 // debug statements here
23184 // 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);
23186 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
23187 if(!isWasmInitialized) {
23188 throw new Error("initializeWasm() must be awaited first!");
23190 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
23191 return nativeResponseValue;
23193 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
23195 export function AnnouncementSignatures_clone_ptr(arg: number): number {
23196 if(!isWasmInitialized) {
23197 throw new Error("initializeWasm() must be awaited first!");
23199 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
23200 return nativeResponseValue;
23202 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
23204 export function AnnouncementSignatures_clone(orig: number): number {
23205 if(!isWasmInitialized) {
23206 throw new Error("initializeWasm() must be awaited first!");
23208 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
23209 return nativeResponseValue;
23211 // void NetAddress_free(struct LDKNetAddress this_ptr);
23213 export function NetAddress_free(this_ptr: number): void {
23214 if(!isWasmInitialized) {
23215 throw new Error("initializeWasm() must be awaited first!");
23217 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
23218 // debug statements here
23220 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
23222 export function NetAddress_clone_ptr(arg: number): number {
23223 if(!isWasmInitialized) {
23224 throw new Error("initializeWasm() must be awaited first!");
23226 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
23227 return nativeResponseValue;
23229 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
23231 export function NetAddress_clone(orig: number): number {
23232 if(!isWasmInitialized) {
23233 throw new Error("initializeWasm() must be awaited first!");
23235 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
23236 return nativeResponseValue;
23238 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
23240 export function NetAddress_ipv4(addr: number, port: number): number {
23241 if(!isWasmInitialized) {
23242 throw new Error("initializeWasm() must be awaited first!");
23244 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
23245 return nativeResponseValue;
23247 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
23249 export function NetAddress_ipv6(addr: number, port: number): number {
23250 if(!isWasmInitialized) {
23251 throw new Error("initializeWasm() must be awaited first!");
23253 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
23254 return nativeResponseValue;
23256 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
23258 export function NetAddress_onion_v2(a: number): number {
23259 if(!isWasmInitialized) {
23260 throw new Error("initializeWasm() must be awaited first!");
23262 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
23263 return nativeResponseValue;
23265 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
23267 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
23268 if(!isWasmInitialized) {
23269 throw new Error("initializeWasm() must be awaited first!");
23271 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
23272 return nativeResponseValue;
23274 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
23276 export function NetAddress_hostname(hostname: number, port: number): number {
23277 if(!isWasmInitialized) {
23278 throw new Error("initializeWasm() must be awaited first!");
23280 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
23281 return nativeResponseValue;
23283 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
23285 export function NetAddress_write(obj: number): number {
23286 if(!isWasmInitialized) {
23287 throw new Error("initializeWasm() must be awaited first!");
23289 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
23290 return nativeResponseValue;
23292 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
23294 export function NetAddress_read(ser: number): number {
23295 if(!isWasmInitialized) {
23296 throw new Error("initializeWasm() must be awaited first!");
23298 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
23299 return nativeResponseValue;
23301 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
23303 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
23304 if(!isWasmInitialized) {
23305 throw new Error("initializeWasm() must be awaited first!");
23307 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
23308 // debug statements here
23310 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23312 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
23313 if(!isWasmInitialized) {
23314 throw new Error("initializeWasm() must be awaited first!");
23316 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
23317 return nativeResponseValue;
23319 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
23321 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
23322 if(!isWasmInitialized) {
23323 throw new Error("initializeWasm() must be awaited first!");
23325 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
23326 // debug statements here
23328 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23330 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
23331 if(!isWasmInitialized) {
23332 throw new Error("initializeWasm() must be awaited first!");
23334 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
23335 return nativeResponseValue;
23337 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
23339 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
23340 if(!isWasmInitialized) {
23341 throw new Error("initializeWasm() must be awaited first!");
23343 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
23344 // debug statements here
23346 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23348 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
23349 if(!isWasmInitialized) {
23350 throw new Error("initializeWasm() must be awaited first!");
23352 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
23353 return nativeResponseValue;
23355 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23357 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
23358 if(!isWasmInitialized) {
23359 throw new Error("initializeWasm() must be awaited first!");
23361 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
23362 // debug statements here
23364 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
23366 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
23367 if(!isWasmInitialized) {
23368 throw new Error("initializeWasm() must be awaited first!");
23370 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
23371 return nativeResponseValue;
23373 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
23375 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
23376 if(!isWasmInitialized) {
23377 throw new Error("initializeWasm() must be awaited first!");
23379 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
23380 // debug statements here
23382 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
23384 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
23385 if(!isWasmInitialized) {
23386 throw new Error("initializeWasm() must be awaited first!");
23388 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
23389 return nativeResponseValue;
23391 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23393 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
23394 if(!isWasmInitialized) {
23395 throw new Error("initializeWasm() must be awaited first!");
23397 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
23398 // debug statements here
23400 // struct LDKCVec_NetAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23402 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: number): number {
23403 if(!isWasmInitialized) {
23404 throw new Error("initializeWasm() must be awaited first!");
23406 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
23407 return nativeResponseValue;
23409 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
23411 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
23412 if(!isWasmInitialized) {
23413 throw new Error("initializeWasm() must be awaited first!");
23415 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
23416 // debug statements here
23418 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
23420 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
23421 if(!isWasmInitialized) {
23422 throw new Error("initializeWasm() must be awaited first!");
23424 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
23425 return nativeResponseValue;
23427 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
23429 export function UnsignedNodeAnnouncement_clone(orig: number): number {
23430 if(!isWasmInitialized) {
23431 throw new Error("initializeWasm() must be awaited first!");
23433 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
23434 return nativeResponseValue;
23436 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
23438 export function NodeAnnouncement_free(this_obj: number): void {
23439 if(!isWasmInitialized) {
23440 throw new Error("initializeWasm() must be awaited first!");
23442 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
23443 // debug statements here
23445 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
23447 export function NodeAnnouncement_get_signature(this_ptr: number): number {
23448 if(!isWasmInitialized) {
23449 throw new Error("initializeWasm() must be awaited first!");
23451 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
23452 return nativeResponseValue;
23454 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23456 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
23457 if(!isWasmInitialized) {
23458 throw new Error("initializeWasm() must be awaited first!");
23460 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
23461 // debug statements here
23463 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
23465 export function NodeAnnouncement_get_contents(this_ptr: number): number {
23466 if(!isWasmInitialized) {
23467 throw new Error("initializeWasm() must be awaited first!");
23469 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
23470 return nativeResponseValue;
23472 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
23474 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
23475 if(!isWasmInitialized) {
23476 throw new Error("initializeWasm() must be awaited first!");
23478 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
23479 // debug statements here
23481 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
23483 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
23484 if(!isWasmInitialized) {
23485 throw new Error("initializeWasm() must be awaited first!");
23487 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
23488 return nativeResponseValue;
23490 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
23492 export function NodeAnnouncement_clone_ptr(arg: number): number {
23493 if(!isWasmInitialized) {
23494 throw new Error("initializeWasm() must be awaited first!");
23496 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
23497 return nativeResponseValue;
23499 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
23501 export function NodeAnnouncement_clone(orig: number): number {
23502 if(!isWasmInitialized) {
23503 throw new Error("initializeWasm() must be awaited first!");
23505 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
23506 return nativeResponseValue;
23508 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
23510 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
23511 if(!isWasmInitialized) {
23512 throw new Error("initializeWasm() must be awaited first!");
23514 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
23515 // debug statements here
23517 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23519 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
23520 if(!isWasmInitialized) {
23521 throw new Error("initializeWasm() must be awaited first!");
23523 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
23524 return nativeResponseValue;
23526 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
23528 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
23529 if(!isWasmInitialized) {
23530 throw new Error("initializeWasm() must be awaited first!");
23532 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
23533 // debug statements here
23535 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
23537 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
23538 if(!isWasmInitialized) {
23539 throw new Error("initializeWasm() must be awaited first!");
23541 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
23542 return nativeResponseValue;
23544 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23546 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
23547 if(!isWasmInitialized) {
23548 throw new Error("initializeWasm() must be awaited first!");
23550 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
23551 // debug statements here
23553 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23555 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
23556 if(!isWasmInitialized) {
23557 throw new Error("initializeWasm() must be awaited first!");
23559 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
23560 return nativeResponseValue;
23562 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
23564 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
23565 if(!isWasmInitialized) {
23566 throw new Error("initializeWasm() must be awaited first!");
23568 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
23569 // debug statements here
23571 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23573 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
23574 if(!isWasmInitialized) {
23575 throw new Error("initializeWasm() must be awaited first!");
23577 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
23578 return nativeResponseValue;
23580 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23582 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
23583 if(!isWasmInitialized) {
23584 throw new Error("initializeWasm() must be awaited first!");
23586 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
23587 // debug statements here
23589 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23591 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
23592 if(!isWasmInitialized) {
23593 throw new Error("initializeWasm() must be awaited first!");
23595 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
23596 return nativeResponseValue;
23598 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23600 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
23601 if(!isWasmInitialized) {
23602 throw new Error("initializeWasm() must be awaited first!");
23604 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
23605 // debug statements here
23607 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23609 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
23610 if(!isWasmInitialized) {
23611 throw new Error("initializeWasm() must be awaited first!");
23613 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
23614 return nativeResponseValue;
23616 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23618 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
23619 if(!isWasmInitialized) {
23620 throw new Error("initializeWasm() must be awaited first!");
23622 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
23623 // debug statements here
23625 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23627 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
23628 if(!isWasmInitialized) {
23629 throw new Error("initializeWasm() must be awaited first!");
23631 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
23632 return nativeResponseValue;
23634 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23636 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
23637 if(!isWasmInitialized) {
23638 throw new Error("initializeWasm() must be awaited first!");
23640 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
23641 // debug statements here
23643 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
23645 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
23646 if(!isWasmInitialized) {
23647 throw new Error("initializeWasm() must be awaited first!");
23649 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
23650 return nativeResponseValue;
23652 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
23654 export function UnsignedChannelAnnouncement_clone(orig: number): number {
23655 if(!isWasmInitialized) {
23656 throw new Error("initializeWasm() must be awaited first!");
23658 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
23659 return nativeResponseValue;
23661 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
23663 export function ChannelAnnouncement_free(this_obj: number): void {
23664 if(!isWasmInitialized) {
23665 throw new Error("initializeWasm() must be awaited first!");
23667 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
23668 // debug statements here
23670 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23672 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
23673 if(!isWasmInitialized) {
23674 throw new Error("initializeWasm() must be awaited first!");
23676 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
23677 return nativeResponseValue;
23679 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23681 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
23682 if(!isWasmInitialized) {
23683 throw new Error("initializeWasm() must be awaited first!");
23685 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
23686 // debug statements here
23688 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23690 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
23691 if(!isWasmInitialized) {
23692 throw new Error("initializeWasm() must be awaited first!");
23694 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
23695 return nativeResponseValue;
23697 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23699 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
23700 if(!isWasmInitialized) {
23701 throw new Error("initializeWasm() must be awaited first!");
23703 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
23704 // debug statements here
23706 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23708 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
23709 if(!isWasmInitialized) {
23710 throw new Error("initializeWasm() must be awaited first!");
23712 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
23713 return nativeResponseValue;
23715 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23717 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
23718 if(!isWasmInitialized) {
23719 throw new Error("initializeWasm() must be awaited first!");
23721 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
23722 // debug statements here
23724 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23726 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
23727 if(!isWasmInitialized) {
23728 throw new Error("initializeWasm() must be awaited first!");
23730 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
23731 return nativeResponseValue;
23733 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23735 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
23736 if(!isWasmInitialized) {
23737 throw new Error("initializeWasm() must be awaited first!");
23739 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
23740 // debug statements here
23742 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23744 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
23745 if(!isWasmInitialized) {
23746 throw new Error("initializeWasm() must be awaited first!");
23748 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
23749 return nativeResponseValue;
23751 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
23753 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
23754 if(!isWasmInitialized) {
23755 throw new Error("initializeWasm() must be awaited first!");
23757 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
23758 // debug statements here
23760 // 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);
23762 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: number): number {
23763 if(!isWasmInitialized) {
23764 throw new Error("initializeWasm() must be awaited first!");
23766 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
23767 return nativeResponseValue;
23769 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
23771 export function ChannelAnnouncement_clone_ptr(arg: number): number {
23772 if(!isWasmInitialized) {
23773 throw new Error("initializeWasm() must be awaited first!");
23775 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
23776 return nativeResponseValue;
23778 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
23780 export function ChannelAnnouncement_clone(orig: number): number {
23781 if(!isWasmInitialized) {
23782 throw new Error("initializeWasm() must be awaited first!");
23784 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
23785 return nativeResponseValue;
23787 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
23789 export function UnsignedChannelUpdate_free(this_obj: number): void {
23790 if(!isWasmInitialized) {
23791 throw new Error("initializeWasm() must be awaited first!");
23793 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
23794 // debug statements here
23796 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
23798 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
23799 if(!isWasmInitialized) {
23800 throw new Error("initializeWasm() must be awaited first!");
23802 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
23803 return nativeResponseValue;
23805 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23807 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
23808 if(!isWasmInitialized) {
23809 throw new Error("initializeWasm() must be awaited first!");
23811 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23812 // debug statements here
23814 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23816 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
23817 if(!isWasmInitialized) {
23818 throw new Error("initializeWasm() must be awaited first!");
23820 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23821 return nativeResponseValue;
23823 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23825 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
23826 if(!isWasmInitialized) {
23827 throw new Error("initializeWasm() must be awaited first!");
23829 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23830 // debug statements here
23832 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23834 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
23835 if(!isWasmInitialized) {
23836 throw new Error("initializeWasm() must be awaited first!");
23838 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23839 return nativeResponseValue;
23841 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23843 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
23844 if(!isWasmInitialized) {
23845 throw new Error("initializeWasm() must be awaited first!");
23847 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23848 // debug statements here
23850 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23852 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
23853 if(!isWasmInitialized) {
23854 throw new Error("initializeWasm() must be awaited first!");
23856 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23857 return nativeResponseValue;
23859 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23861 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
23862 if(!isWasmInitialized) {
23863 throw new Error("initializeWasm() must be awaited first!");
23865 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23866 // debug statements here
23868 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23870 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
23871 if(!isWasmInitialized) {
23872 throw new Error("initializeWasm() must be awaited first!");
23874 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23875 return nativeResponseValue;
23877 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23879 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23880 if(!isWasmInitialized) {
23881 throw new Error("initializeWasm() must be awaited first!");
23883 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23884 // debug statements here
23886 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23888 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
23889 if(!isWasmInitialized) {
23890 throw new Error("initializeWasm() must be awaited first!");
23892 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23893 return nativeResponseValue;
23895 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23897 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23898 if(!isWasmInitialized) {
23899 throw new Error("initializeWasm() must be awaited first!");
23901 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23902 // debug statements here
23904 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23906 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: number): bigint {
23907 if(!isWasmInitialized) {
23908 throw new Error("initializeWasm() must be awaited first!");
23910 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
23911 return nativeResponseValue;
23913 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23915 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: number, val: bigint): void {
23916 if(!isWasmInitialized) {
23917 throw new Error("initializeWasm() must be awaited first!");
23919 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
23920 // debug statements here
23922 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23924 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
23925 if(!isWasmInitialized) {
23926 throw new Error("initializeWasm() must be awaited first!");
23928 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23929 return nativeResponseValue;
23931 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23933 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
23934 if(!isWasmInitialized) {
23935 throw new Error("initializeWasm() must be awaited first!");
23937 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23938 // debug statements here
23940 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23942 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
23943 if(!isWasmInitialized) {
23944 throw new Error("initializeWasm() must be awaited first!");
23946 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23947 return nativeResponseValue;
23949 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23951 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
23952 if(!isWasmInitialized) {
23953 throw new Error("initializeWasm() must be awaited first!");
23955 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23956 // debug statements here
23958 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23960 export function UnsignedChannelUpdate_get_excess_data(this_ptr: number): number {
23961 if(!isWasmInitialized) {
23962 throw new Error("initializeWasm() must be awaited first!");
23964 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
23965 return nativeResponseValue;
23967 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23969 export function UnsignedChannelUpdate_set_excess_data(this_ptr: number, val: number): void {
23970 if(!isWasmInitialized) {
23971 throw new Error("initializeWasm() must be awaited first!");
23973 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23974 // debug statements here
23976 // 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);
23978 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): number {
23979 if(!isWasmInitialized) {
23980 throw new Error("initializeWasm() must be awaited first!");
23982 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);
23983 return nativeResponseValue;
23985 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23987 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
23988 if(!isWasmInitialized) {
23989 throw new Error("initializeWasm() must be awaited first!");
23991 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23992 return nativeResponseValue;
23994 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
23996 export function UnsignedChannelUpdate_clone(orig: number): number {
23997 if(!isWasmInitialized) {
23998 throw new Error("initializeWasm() must be awaited first!");
24000 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
24001 return nativeResponseValue;
24003 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
24005 export function ChannelUpdate_free(this_obj: number): void {
24006 if(!isWasmInitialized) {
24007 throw new Error("initializeWasm() must be awaited first!");
24009 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
24010 // debug statements here
24012 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
24014 export function ChannelUpdate_get_signature(this_ptr: number): number {
24015 if(!isWasmInitialized) {
24016 throw new Error("initializeWasm() must be awaited first!");
24018 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
24019 return nativeResponseValue;
24021 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
24023 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
24024 if(!isWasmInitialized) {
24025 throw new Error("initializeWasm() must be awaited first!");
24027 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
24028 // debug statements here
24030 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
24032 export function ChannelUpdate_get_contents(this_ptr: number): number {
24033 if(!isWasmInitialized) {
24034 throw new Error("initializeWasm() must be awaited first!");
24036 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
24037 return nativeResponseValue;
24039 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
24041 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
24042 if(!isWasmInitialized) {
24043 throw new Error("initializeWasm() must be awaited first!");
24045 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
24046 // debug statements here
24048 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
24050 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
24051 if(!isWasmInitialized) {
24052 throw new Error("initializeWasm() must be awaited first!");
24054 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
24055 return nativeResponseValue;
24057 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
24059 export function ChannelUpdate_clone_ptr(arg: number): number {
24060 if(!isWasmInitialized) {
24061 throw new Error("initializeWasm() must be awaited first!");
24063 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
24064 return nativeResponseValue;
24066 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
24068 export function ChannelUpdate_clone(orig: number): number {
24069 if(!isWasmInitialized) {
24070 throw new Error("initializeWasm() must be awaited first!");
24072 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
24073 return nativeResponseValue;
24075 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
24077 export function QueryChannelRange_free(this_obj: number): void {
24078 if(!isWasmInitialized) {
24079 throw new Error("initializeWasm() must be awaited first!");
24081 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
24082 // debug statements here
24084 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
24086 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
24087 if(!isWasmInitialized) {
24088 throw new Error("initializeWasm() must be awaited first!");
24090 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
24091 return nativeResponseValue;
24093 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24095 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
24096 if(!isWasmInitialized) {
24097 throw new Error("initializeWasm() must be awaited first!");
24099 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
24100 // debug statements here
24102 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
24104 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
24105 if(!isWasmInitialized) {
24106 throw new Error("initializeWasm() must be awaited first!");
24108 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
24109 return nativeResponseValue;
24111 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24113 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
24114 if(!isWasmInitialized) {
24115 throw new Error("initializeWasm() must be awaited first!");
24117 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
24118 // debug statements here
24120 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
24122 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
24123 if(!isWasmInitialized) {
24124 throw new Error("initializeWasm() must be awaited first!");
24126 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
24127 return nativeResponseValue;
24129 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24131 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
24132 if(!isWasmInitialized) {
24133 throw new Error("initializeWasm() must be awaited first!");
24135 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
24136 // debug statements here
24138 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
24140 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
24141 if(!isWasmInitialized) {
24142 throw new Error("initializeWasm() must be awaited first!");
24144 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
24145 return nativeResponseValue;
24147 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
24149 export function QueryChannelRange_clone_ptr(arg: number): number {
24150 if(!isWasmInitialized) {
24151 throw new Error("initializeWasm() must be awaited first!");
24153 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
24154 return nativeResponseValue;
24156 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
24158 export function QueryChannelRange_clone(orig: number): number {
24159 if(!isWasmInitialized) {
24160 throw new Error("initializeWasm() must be awaited first!");
24162 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
24163 return nativeResponseValue;
24165 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
24167 export function ReplyChannelRange_free(this_obj: number): void {
24168 if(!isWasmInitialized) {
24169 throw new Error("initializeWasm() must be awaited first!");
24171 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
24172 // debug statements here
24174 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
24176 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
24177 if(!isWasmInitialized) {
24178 throw new Error("initializeWasm() must be awaited first!");
24180 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
24181 return nativeResponseValue;
24183 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24185 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
24186 if(!isWasmInitialized) {
24187 throw new Error("initializeWasm() must be awaited first!");
24189 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
24190 // debug statements here
24192 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24194 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
24195 if(!isWasmInitialized) {
24196 throw new Error("initializeWasm() must be awaited first!");
24198 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
24199 return nativeResponseValue;
24201 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24203 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
24204 if(!isWasmInitialized) {
24205 throw new Error("initializeWasm() must be awaited first!");
24207 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
24208 // debug statements here
24210 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24212 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
24213 if(!isWasmInitialized) {
24214 throw new Error("initializeWasm() must be awaited first!");
24216 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
24217 return nativeResponseValue;
24219 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24221 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
24222 if(!isWasmInitialized) {
24223 throw new Error("initializeWasm() must be awaited first!");
24225 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
24226 // debug statements here
24228 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24230 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
24231 if(!isWasmInitialized) {
24232 throw new Error("initializeWasm() must be awaited first!");
24234 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
24235 return nativeResponseValue;
24237 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
24239 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
24240 if(!isWasmInitialized) {
24241 throw new Error("initializeWasm() must be awaited first!");
24243 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
24244 // debug statements here
24246 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24248 export function ReplyChannelRange_get_short_channel_ids(this_ptr: number): number {
24249 if(!isWasmInitialized) {
24250 throw new Error("initializeWasm() must be awaited first!");
24252 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
24253 return nativeResponseValue;
24255 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24257 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
24258 if(!isWasmInitialized) {
24259 throw new Error("initializeWasm() must be awaited first!");
24261 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
24262 // debug statements here
24264 // 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);
24266 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): number {
24267 if(!isWasmInitialized) {
24268 throw new Error("initializeWasm() must be awaited first!");
24270 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
24271 return nativeResponseValue;
24273 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
24275 export function ReplyChannelRange_clone_ptr(arg: number): number {
24276 if(!isWasmInitialized) {
24277 throw new Error("initializeWasm() must be awaited first!");
24279 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
24280 return nativeResponseValue;
24282 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
24284 export function ReplyChannelRange_clone(orig: number): number {
24285 if(!isWasmInitialized) {
24286 throw new Error("initializeWasm() must be awaited first!");
24288 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
24289 return nativeResponseValue;
24291 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
24293 export function QueryShortChannelIds_free(this_obj: number): void {
24294 if(!isWasmInitialized) {
24295 throw new Error("initializeWasm() must be awaited first!");
24297 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
24298 // debug statements here
24300 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
24302 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
24303 if(!isWasmInitialized) {
24304 throw new Error("initializeWasm() must be awaited first!");
24306 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
24307 return nativeResponseValue;
24309 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24311 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
24312 if(!isWasmInitialized) {
24313 throw new Error("initializeWasm() must be awaited first!");
24315 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
24316 // debug statements here
24318 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
24320 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: number): number {
24321 if(!isWasmInitialized) {
24322 throw new Error("initializeWasm() must be awaited first!");
24324 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
24325 return nativeResponseValue;
24327 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24329 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
24330 if(!isWasmInitialized) {
24331 throw new Error("initializeWasm() must be awaited first!");
24333 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
24334 // debug statements here
24336 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
24338 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
24339 if(!isWasmInitialized) {
24340 throw new Error("initializeWasm() must be awaited first!");
24342 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
24343 return nativeResponseValue;
24345 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
24347 export function QueryShortChannelIds_clone_ptr(arg: number): number {
24348 if(!isWasmInitialized) {
24349 throw new Error("initializeWasm() must be awaited first!");
24351 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
24352 return nativeResponseValue;
24354 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
24356 export function QueryShortChannelIds_clone(orig: number): number {
24357 if(!isWasmInitialized) {
24358 throw new Error("initializeWasm() must be awaited first!");
24360 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
24361 return nativeResponseValue;
24363 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
24365 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
24366 if(!isWasmInitialized) {
24367 throw new Error("initializeWasm() must be awaited first!");
24369 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
24370 // debug statements here
24372 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
24374 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
24375 if(!isWasmInitialized) {
24376 throw new Error("initializeWasm() must be awaited first!");
24378 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
24379 return nativeResponseValue;
24381 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24383 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
24384 if(!isWasmInitialized) {
24385 throw new Error("initializeWasm() must be awaited first!");
24387 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
24388 // debug statements here
24390 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
24392 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
24393 if(!isWasmInitialized) {
24394 throw new Error("initializeWasm() must be awaited first!");
24396 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
24397 return nativeResponseValue;
24399 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
24401 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
24402 if(!isWasmInitialized) {
24403 throw new Error("initializeWasm() must be awaited first!");
24405 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
24406 // debug statements here
24408 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
24410 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
24411 if(!isWasmInitialized) {
24412 throw new Error("initializeWasm() must be awaited first!");
24414 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
24415 return nativeResponseValue;
24417 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
24419 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
24420 if(!isWasmInitialized) {
24421 throw new Error("initializeWasm() must be awaited first!");
24423 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
24424 return nativeResponseValue;
24426 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
24428 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
24429 if(!isWasmInitialized) {
24430 throw new Error("initializeWasm() must be awaited first!");
24432 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
24433 return nativeResponseValue;
24435 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
24437 export function GossipTimestampFilter_free(this_obj: number): void {
24438 if(!isWasmInitialized) {
24439 throw new Error("initializeWasm() must be awaited first!");
24441 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
24442 // debug statements here
24444 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
24446 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
24447 if(!isWasmInitialized) {
24448 throw new Error("initializeWasm() must be awaited first!");
24450 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
24451 return nativeResponseValue;
24453 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24455 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
24456 if(!isWasmInitialized) {
24457 throw new Error("initializeWasm() must be awaited first!");
24459 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
24460 // debug statements here
24462 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
24464 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
24465 if(!isWasmInitialized) {
24466 throw new Error("initializeWasm() must be awaited first!");
24468 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
24469 return nativeResponseValue;
24471 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
24473 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
24474 if(!isWasmInitialized) {
24475 throw new Error("initializeWasm() must be awaited first!");
24477 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
24478 // debug statements here
24480 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
24482 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
24483 if(!isWasmInitialized) {
24484 throw new Error("initializeWasm() must be awaited first!");
24486 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
24487 return nativeResponseValue;
24489 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
24491 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
24492 if(!isWasmInitialized) {
24493 throw new Error("initializeWasm() must be awaited first!");
24495 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
24496 // debug statements here
24498 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
24500 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
24501 if(!isWasmInitialized) {
24502 throw new Error("initializeWasm() must be awaited first!");
24504 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
24505 return nativeResponseValue;
24507 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
24509 export function GossipTimestampFilter_clone_ptr(arg: number): number {
24510 if(!isWasmInitialized) {
24511 throw new Error("initializeWasm() must be awaited first!");
24513 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
24514 return nativeResponseValue;
24516 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
24518 export function GossipTimestampFilter_clone(orig: number): number {
24519 if(!isWasmInitialized) {
24520 throw new Error("initializeWasm() must be awaited first!");
24522 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
24523 return nativeResponseValue;
24525 // void ErrorAction_free(struct LDKErrorAction this_ptr);
24527 export function ErrorAction_free(this_ptr: number): void {
24528 if(!isWasmInitialized) {
24529 throw new Error("initializeWasm() must be awaited first!");
24531 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
24532 // debug statements here
24534 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
24536 export function ErrorAction_clone_ptr(arg: number): number {
24537 if(!isWasmInitialized) {
24538 throw new Error("initializeWasm() must be awaited first!");
24540 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
24541 return nativeResponseValue;
24543 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
24545 export function ErrorAction_clone(orig: number): number {
24546 if(!isWasmInitialized) {
24547 throw new Error("initializeWasm() must be awaited first!");
24549 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
24550 return nativeResponseValue;
24552 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
24554 export function ErrorAction_disconnect_peer(msg: number): number {
24555 if(!isWasmInitialized) {
24556 throw new Error("initializeWasm() must be awaited first!");
24558 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
24559 return nativeResponseValue;
24561 // struct LDKErrorAction ErrorAction_ignore_error(void);
24563 export function ErrorAction_ignore_error(): number {
24564 if(!isWasmInitialized) {
24565 throw new Error("initializeWasm() must be awaited first!");
24567 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
24568 return nativeResponseValue;
24570 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
24572 export function ErrorAction_ignore_and_log(a: Level): number {
24573 if(!isWasmInitialized) {
24574 throw new Error("initializeWasm() must be awaited first!");
24576 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
24577 return nativeResponseValue;
24579 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
24581 export function ErrorAction_ignore_duplicate_gossip(): number {
24582 if(!isWasmInitialized) {
24583 throw new Error("initializeWasm() must be awaited first!");
24585 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
24586 return nativeResponseValue;
24588 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
24590 export function ErrorAction_send_error_message(msg: number): number {
24591 if(!isWasmInitialized) {
24592 throw new Error("initializeWasm() must be awaited first!");
24594 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
24595 return nativeResponseValue;
24597 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
24599 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
24600 if(!isWasmInitialized) {
24601 throw new Error("initializeWasm() must be awaited first!");
24603 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
24604 return nativeResponseValue;
24606 // void LightningError_free(struct LDKLightningError this_obj);
24608 export function LightningError_free(this_obj: number): void {
24609 if(!isWasmInitialized) {
24610 throw new Error("initializeWasm() must be awaited first!");
24612 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
24613 // debug statements here
24615 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
24617 export function LightningError_get_err(this_ptr: number): number {
24618 if(!isWasmInitialized) {
24619 throw new Error("initializeWasm() must be awaited first!");
24621 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
24622 return nativeResponseValue;
24624 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
24626 export function LightningError_set_err(this_ptr: number, val: number): void {
24627 if(!isWasmInitialized) {
24628 throw new Error("initializeWasm() must be awaited first!");
24630 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
24631 // debug statements here
24633 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
24635 export function LightningError_get_action(this_ptr: number): number {
24636 if(!isWasmInitialized) {
24637 throw new Error("initializeWasm() must be awaited first!");
24639 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
24640 return nativeResponseValue;
24642 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
24644 export function LightningError_set_action(this_ptr: number, val: number): void {
24645 if(!isWasmInitialized) {
24646 throw new Error("initializeWasm() must be awaited first!");
24648 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
24649 // debug statements here
24651 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
24653 export function LightningError_new(err_arg: number, action_arg: number): number {
24654 if(!isWasmInitialized) {
24655 throw new Error("initializeWasm() must be awaited first!");
24657 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
24658 return nativeResponseValue;
24660 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
24662 export function LightningError_clone_ptr(arg: number): number {
24663 if(!isWasmInitialized) {
24664 throw new Error("initializeWasm() must be awaited first!");
24666 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
24667 return nativeResponseValue;
24669 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
24671 export function LightningError_clone(orig: number): number {
24672 if(!isWasmInitialized) {
24673 throw new Error("initializeWasm() must be awaited first!");
24675 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
24676 return nativeResponseValue;
24678 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
24680 export function CommitmentUpdate_free(this_obj: number): void {
24681 if(!isWasmInitialized) {
24682 throw new Error("initializeWasm() must be awaited first!");
24684 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
24685 // debug statements here
24687 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24689 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
24690 if(!isWasmInitialized) {
24691 throw new Error("initializeWasm() must be awaited first!");
24693 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
24694 return nativeResponseValue;
24696 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
24698 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
24699 if(!isWasmInitialized) {
24700 throw new Error("initializeWasm() must be awaited first!");
24702 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
24703 // debug statements here
24705 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24707 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
24708 if(!isWasmInitialized) {
24709 throw new Error("initializeWasm() must be awaited first!");
24711 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
24712 return nativeResponseValue;
24714 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
24716 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
24717 if(!isWasmInitialized) {
24718 throw new Error("initializeWasm() must be awaited first!");
24720 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
24721 // debug statements here
24723 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24725 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
24726 if(!isWasmInitialized) {
24727 throw new Error("initializeWasm() must be awaited first!");
24729 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
24730 return nativeResponseValue;
24732 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
24734 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
24735 if(!isWasmInitialized) {
24736 throw new Error("initializeWasm() must be awaited first!");
24738 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
24739 // debug statements here
24741 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24743 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
24744 if(!isWasmInitialized) {
24745 throw new Error("initializeWasm() must be awaited first!");
24747 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
24748 return nativeResponseValue;
24750 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
24752 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
24753 if(!isWasmInitialized) {
24754 throw new Error("initializeWasm() must be awaited first!");
24756 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
24757 // debug statements here
24759 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24761 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
24762 if(!isWasmInitialized) {
24763 throw new Error("initializeWasm() must be awaited first!");
24765 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
24766 return nativeResponseValue;
24768 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
24770 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
24771 if(!isWasmInitialized) {
24772 throw new Error("initializeWasm() must be awaited first!");
24774 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
24775 // debug statements here
24777 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24779 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
24780 if(!isWasmInitialized) {
24781 throw new Error("initializeWasm() must be awaited first!");
24783 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
24784 return nativeResponseValue;
24786 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
24788 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
24789 if(!isWasmInitialized) {
24790 throw new Error("initializeWasm() must be awaited first!");
24792 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
24793 // debug statements here
24795 // 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);
24797 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: number, commitment_signed_arg: number): number {
24798 if(!isWasmInitialized) {
24799 throw new Error("initializeWasm() must be awaited first!");
24801 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);
24802 return nativeResponseValue;
24804 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
24806 export function CommitmentUpdate_clone_ptr(arg: number): number {
24807 if(!isWasmInitialized) {
24808 throw new Error("initializeWasm() must be awaited first!");
24810 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
24811 return nativeResponseValue;
24813 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
24815 export function CommitmentUpdate_clone(orig: number): number {
24816 if(!isWasmInitialized) {
24817 throw new Error("initializeWasm() must be awaited first!");
24819 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
24820 return nativeResponseValue;
24822 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
24824 export function ChannelMessageHandler_free(this_ptr: number): void {
24825 if(!isWasmInitialized) {
24826 throw new Error("initializeWasm() must be awaited first!");
24828 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
24829 // debug statements here
24831 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
24833 export function RoutingMessageHandler_free(this_ptr: number): void {
24834 if(!isWasmInitialized) {
24835 throw new Error("initializeWasm() must be awaited first!");
24837 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
24838 // debug statements here
24840 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
24842 export function AcceptChannel_write(obj: number): number {
24843 if(!isWasmInitialized) {
24844 throw new Error("initializeWasm() must be awaited first!");
24846 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
24847 return nativeResponseValue;
24849 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
24851 export function AcceptChannel_read(ser: number): number {
24852 if(!isWasmInitialized) {
24853 throw new Error("initializeWasm() must be awaited first!");
24855 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
24856 return nativeResponseValue;
24858 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
24860 export function AnnouncementSignatures_write(obj: number): number {
24861 if(!isWasmInitialized) {
24862 throw new Error("initializeWasm() must be awaited first!");
24864 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24865 return nativeResponseValue;
24867 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24869 export function AnnouncementSignatures_read(ser: number): number {
24870 if(!isWasmInitialized) {
24871 throw new Error("initializeWasm() must be awaited first!");
24873 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24874 return nativeResponseValue;
24876 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24878 export function ChannelReestablish_write(obj: number): number {
24879 if(!isWasmInitialized) {
24880 throw new Error("initializeWasm() must be awaited first!");
24882 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24883 return nativeResponseValue;
24885 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24887 export function ChannelReestablish_read(ser: number): number {
24888 if(!isWasmInitialized) {
24889 throw new Error("initializeWasm() must be awaited first!");
24891 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24892 return nativeResponseValue;
24894 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24896 export function ClosingSigned_write(obj: number): number {
24897 if(!isWasmInitialized) {
24898 throw new Error("initializeWasm() must be awaited first!");
24900 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24901 return nativeResponseValue;
24903 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24905 export function ClosingSigned_read(ser: number): number {
24906 if(!isWasmInitialized) {
24907 throw new Error("initializeWasm() must be awaited first!");
24909 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24910 return nativeResponseValue;
24912 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24914 export function ClosingSignedFeeRange_write(obj: number): number {
24915 if(!isWasmInitialized) {
24916 throw new Error("initializeWasm() must be awaited first!");
24918 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24919 return nativeResponseValue;
24921 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24923 export function ClosingSignedFeeRange_read(ser: number): number {
24924 if(!isWasmInitialized) {
24925 throw new Error("initializeWasm() must be awaited first!");
24927 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24928 return nativeResponseValue;
24930 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24932 export function CommitmentSigned_write(obj: number): number {
24933 if(!isWasmInitialized) {
24934 throw new Error("initializeWasm() must be awaited first!");
24936 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24937 return nativeResponseValue;
24939 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24941 export function CommitmentSigned_read(ser: number): number {
24942 if(!isWasmInitialized) {
24943 throw new Error("initializeWasm() must be awaited first!");
24945 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24946 return nativeResponseValue;
24948 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24950 export function FundingCreated_write(obj: number): number {
24951 if(!isWasmInitialized) {
24952 throw new Error("initializeWasm() must be awaited first!");
24954 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24955 return nativeResponseValue;
24957 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24959 export function FundingCreated_read(ser: number): number {
24960 if(!isWasmInitialized) {
24961 throw new Error("initializeWasm() must be awaited first!");
24963 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24964 return nativeResponseValue;
24966 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24968 export function FundingSigned_write(obj: number): number {
24969 if(!isWasmInitialized) {
24970 throw new Error("initializeWasm() must be awaited first!");
24972 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24973 return nativeResponseValue;
24975 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24977 export function FundingSigned_read(ser: number): number {
24978 if(!isWasmInitialized) {
24979 throw new Error("initializeWasm() must be awaited first!");
24981 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24982 return nativeResponseValue;
24984 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24986 export function ChannelReady_write(obj: number): number {
24987 if(!isWasmInitialized) {
24988 throw new Error("initializeWasm() must be awaited first!");
24990 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24991 return nativeResponseValue;
24993 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
24995 export function ChannelReady_read(ser: number): number {
24996 if(!isWasmInitialized) {
24997 throw new Error("initializeWasm() must be awaited first!");
24999 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
25000 return nativeResponseValue;
25002 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
25004 export function Init_write(obj: number): number {
25005 if(!isWasmInitialized) {
25006 throw new Error("initializeWasm() must be awaited first!");
25008 const nativeResponseValue = wasm.TS_Init_write(obj);
25009 return nativeResponseValue;
25011 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
25013 export function Init_read(ser: number): number {
25014 if(!isWasmInitialized) {
25015 throw new Error("initializeWasm() must be awaited first!");
25017 const nativeResponseValue = wasm.TS_Init_read(ser);
25018 return nativeResponseValue;
25020 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
25022 export function OpenChannel_write(obj: number): number {
25023 if(!isWasmInitialized) {
25024 throw new Error("initializeWasm() must be awaited first!");
25026 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
25027 return nativeResponseValue;
25029 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
25031 export function OpenChannel_read(ser: number): number {
25032 if(!isWasmInitialized) {
25033 throw new Error("initializeWasm() must be awaited first!");
25035 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
25036 return nativeResponseValue;
25038 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
25040 export function RevokeAndACK_write(obj: number): number {
25041 if(!isWasmInitialized) {
25042 throw new Error("initializeWasm() must be awaited first!");
25044 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
25045 return nativeResponseValue;
25047 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
25049 export function RevokeAndACK_read(ser: number): number {
25050 if(!isWasmInitialized) {
25051 throw new Error("initializeWasm() must be awaited first!");
25053 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
25054 return nativeResponseValue;
25056 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
25058 export function Shutdown_write(obj: number): number {
25059 if(!isWasmInitialized) {
25060 throw new Error("initializeWasm() must be awaited first!");
25062 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
25063 return nativeResponseValue;
25065 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
25067 export function Shutdown_read(ser: number): number {
25068 if(!isWasmInitialized) {
25069 throw new Error("initializeWasm() must be awaited first!");
25071 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
25072 return nativeResponseValue;
25074 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
25076 export function UpdateFailHTLC_write(obj: number): number {
25077 if(!isWasmInitialized) {
25078 throw new Error("initializeWasm() must be awaited first!");
25080 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
25081 return nativeResponseValue;
25083 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
25085 export function UpdateFailHTLC_read(ser: number): number {
25086 if(!isWasmInitialized) {
25087 throw new Error("initializeWasm() must be awaited first!");
25089 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
25090 return nativeResponseValue;
25092 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
25094 export function UpdateFailMalformedHTLC_write(obj: number): number {
25095 if(!isWasmInitialized) {
25096 throw new Error("initializeWasm() must be awaited first!");
25098 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
25099 return nativeResponseValue;
25101 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
25103 export function UpdateFailMalformedHTLC_read(ser: number): number {
25104 if(!isWasmInitialized) {
25105 throw new Error("initializeWasm() must be awaited first!");
25107 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
25108 return nativeResponseValue;
25110 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
25112 export function UpdateFee_write(obj: number): number {
25113 if(!isWasmInitialized) {
25114 throw new Error("initializeWasm() must be awaited first!");
25116 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
25117 return nativeResponseValue;
25119 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
25121 export function UpdateFee_read(ser: number): number {
25122 if(!isWasmInitialized) {
25123 throw new Error("initializeWasm() must be awaited first!");
25125 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
25126 return nativeResponseValue;
25128 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
25130 export function UpdateFulfillHTLC_write(obj: number): number {
25131 if(!isWasmInitialized) {
25132 throw new Error("initializeWasm() must be awaited first!");
25134 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
25135 return nativeResponseValue;
25137 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
25139 export function UpdateFulfillHTLC_read(ser: number): number {
25140 if(!isWasmInitialized) {
25141 throw new Error("initializeWasm() must be awaited first!");
25143 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
25144 return nativeResponseValue;
25146 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
25148 export function UpdateAddHTLC_write(obj: number): number {
25149 if(!isWasmInitialized) {
25150 throw new Error("initializeWasm() must be awaited first!");
25152 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
25153 return nativeResponseValue;
25155 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
25157 export function UpdateAddHTLC_read(ser: number): number {
25158 if(!isWasmInitialized) {
25159 throw new Error("initializeWasm() must be awaited first!");
25161 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
25162 return nativeResponseValue;
25164 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
25166 export function Ping_write(obj: number): number {
25167 if(!isWasmInitialized) {
25168 throw new Error("initializeWasm() must be awaited first!");
25170 const nativeResponseValue = wasm.TS_Ping_write(obj);
25171 return nativeResponseValue;
25173 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
25175 export function Ping_read(ser: number): number {
25176 if(!isWasmInitialized) {
25177 throw new Error("initializeWasm() must be awaited first!");
25179 const nativeResponseValue = wasm.TS_Ping_read(ser);
25180 return nativeResponseValue;
25182 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
25184 export function Pong_write(obj: number): number {
25185 if(!isWasmInitialized) {
25186 throw new Error("initializeWasm() must be awaited first!");
25188 const nativeResponseValue = wasm.TS_Pong_write(obj);
25189 return nativeResponseValue;
25191 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
25193 export function Pong_read(ser: number): number {
25194 if(!isWasmInitialized) {
25195 throw new Error("initializeWasm() must be awaited first!");
25197 const nativeResponseValue = wasm.TS_Pong_read(ser);
25198 return nativeResponseValue;
25200 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
25202 export function UnsignedChannelAnnouncement_write(obj: number): number {
25203 if(!isWasmInitialized) {
25204 throw new Error("initializeWasm() must be awaited first!");
25206 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
25207 return nativeResponseValue;
25209 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
25211 export function UnsignedChannelAnnouncement_read(ser: number): number {
25212 if(!isWasmInitialized) {
25213 throw new Error("initializeWasm() must be awaited first!");
25215 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
25216 return nativeResponseValue;
25218 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
25220 export function ChannelAnnouncement_write(obj: number): number {
25221 if(!isWasmInitialized) {
25222 throw new Error("initializeWasm() must be awaited first!");
25224 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
25225 return nativeResponseValue;
25227 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
25229 export function ChannelAnnouncement_read(ser: number): number {
25230 if(!isWasmInitialized) {
25231 throw new Error("initializeWasm() must be awaited first!");
25233 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
25234 return nativeResponseValue;
25236 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
25238 export function UnsignedChannelUpdate_write(obj: number): number {
25239 if(!isWasmInitialized) {
25240 throw new Error("initializeWasm() must be awaited first!");
25242 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
25243 return nativeResponseValue;
25245 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
25247 export function UnsignedChannelUpdate_read(ser: number): number {
25248 if(!isWasmInitialized) {
25249 throw new Error("initializeWasm() must be awaited first!");
25251 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
25252 return nativeResponseValue;
25254 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
25256 export function ChannelUpdate_write(obj: number): number {
25257 if(!isWasmInitialized) {
25258 throw new Error("initializeWasm() must be awaited first!");
25260 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
25261 return nativeResponseValue;
25263 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
25265 export function ChannelUpdate_read(ser: number): number {
25266 if(!isWasmInitialized) {
25267 throw new Error("initializeWasm() must be awaited first!");
25269 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
25270 return nativeResponseValue;
25272 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
25274 export function ErrorMessage_write(obj: number): number {
25275 if(!isWasmInitialized) {
25276 throw new Error("initializeWasm() must be awaited first!");
25278 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
25279 return nativeResponseValue;
25281 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
25283 export function ErrorMessage_read(ser: number): number {
25284 if(!isWasmInitialized) {
25285 throw new Error("initializeWasm() must be awaited first!");
25287 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
25288 return nativeResponseValue;
25290 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
25292 export function WarningMessage_write(obj: number): number {
25293 if(!isWasmInitialized) {
25294 throw new Error("initializeWasm() must be awaited first!");
25296 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
25297 return nativeResponseValue;
25299 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
25301 export function WarningMessage_read(ser: number): number {
25302 if(!isWasmInitialized) {
25303 throw new Error("initializeWasm() must be awaited first!");
25305 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
25306 return nativeResponseValue;
25308 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
25310 export function UnsignedNodeAnnouncement_write(obj: number): number {
25311 if(!isWasmInitialized) {
25312 throw new Error("initializeWasm() must be awaited first!");
25314 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
25315 return nativeResponseValue;
25317 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
25319 export function UnsignedNodeAnnouncement_read(ser: number): number {
25320 if(!isWasmInitialized) {
25321 throw new Error("initializeWasm() must be awaited first!");
25323 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
25324 return nativeResponseValue;
25326 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
25328 export function NodeAnnouncement_write(obj: number): number {
25329 if(!isWasmInitialized) {
25330 throw new Error("initializeWasm() must be awaited first!");
25332 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
25333 return nativeResponseValue;
25335 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
25337 export function NodeAnnouncement_read(ser: number): number {
25338 if(!isWasmInitialized) {
25339 throw new Error("initializeWasm() must be awaited first!");
25341 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
25342 return nativeResponseValue;
25344 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
25346 export function QueryShortChannelIds_read(ser: number): number {
25347 if(!isWasmInitialized) {
25348 throw new Error("initializeWasm() must be awaited first!");
25350 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
25351 return nativeResponseValue;
25353 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
25355 export function QueryShortChannelIds_write(obj: number): number {
25356 if(!isWasmInitialized) {
25357 throw new Error("initializeWasm() must be awaited first!");
25359 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
25360 return nativeResponseValue;
25362 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
25364 export function ReplyShortChannelIdsEnd_write(obj: number): number {
25365 if(!isWasmInitialized) {
25366 throw new Error("initializeWasm() must be awaited first!");
25368 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
25369 return nativeResponseValue;
25371 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
25373 export function ReplyShortChannelIdsEnd_read(ser: number): number {
25374 if(!isWasmInitialized) {
25375 throw new Error("initializeWasm() must be awaited first!");
25377 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
25378 return nativeResponseValue;
25380 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
25382 export function QueryChannelRange_end_blocknum(this_arg: number): number {
25383 if(!isWasmInitialized) {
25384 throw new Error("initializeWasm() must be awaited first!");
25386 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
25387 return nativeResponseValue;
25389 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
25391 export function QueryChannelRange_write(obj: number): number {
25392 if(!isWasmInitialized) {
25393 throw new Error("initializeWasm() must be awaited first!");
25395 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
25396 return nativeResponseValue;
25398 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
25400 export function QueryChannelRange_read(ser: number): number {
25401 if(!isWasmInitialized) {
25402 throw new Error("initializeWasm() must be awaited first!");
25404 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
25405 return nativeResponseValue;
25407 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
25409 export function ReplyChannelRange_read(ser: number): number {
25410 if(!isWasmInitialized) {
25411 throw new Error("initializeWasm() must be awaited first!");
25413 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
25414 return nativeResponseValue;
25416 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
25418 export function ReplyChannelRange_write(obj: number): number {
25419 if(!isWasmInitialized) {
25420 throw new Error("initializeWasm() must be awaited first!");
25422 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
25423 return nativeResponseValue;
25425 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
25427 export function GossipTimestampFilter_write(obj: number): number {
25428 if(!isWasmInitialized) {
25429 throw new Error("initializeWasm() must be awaited first!");
25431 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
25432 return nativeResponseValue;
25434 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
25436 export function GossipTimestampFilter_read(ser: number): number {
25437 if(!isWasmInitialized) {
25438 throw new Error("initializeWasm() must be awaited first!");
25440 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
25441 return nativeResponseValue;
25443 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
25445 export function CustomMessageHandler_free(this_ptr: number): void {
25446 if(!isWasmInitialized) {
25447 throw new Error("initializeWasm() must be awaited first!");
25449 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
25450 // debug statements here
25452 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
25454 export function IgnoringMessageHandler_free(this_obj: number): void {
25455 if(!isWasmInitialized) {
25456 throw new Error("initializeWasm() must be awaited first!");
25458 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
25459 // debug statements here
25461 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
25463 export function IgnoringMessageHandler_new(): number {
25464 if(!isWasmInitialized) {
25465 throw new Error("initializeWasm() must be awaited first!");
25467 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
25468 return nativeResponseValue;
25470 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25472 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
25473 if(!isWasmInitialized) {
25474 throw new Error("initializeWasm() must be awaited first!");
25476 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
25477 return nativeResponseValue;
25479 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25481 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
25482 if(!isWasmInitialized) {
25483 throw new Error("initializeWasm() must be awaited first!");
25485 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
25486 return nativeResponseValue;
25488 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25490 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
25491 if(!isWasmInitialized) {
25492 throw new Error("initializeWasm() must be awaited first!");
25494 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
25495 return nativeResponseValue;
25497 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25499 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
25500 if(!isWasmInitialized) {
25501 throw new Error("initializeWasm() must be awaited first!");
25503 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
25504 return nativeResponseValue;
25506 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
25508 export function ErroringMessageHandler_free(this_obj: number): void {
25509 if(!isWasmInitialized) {
25510 throw new Error("initializeWasm() must be awaited first!");
25512 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
25513 // debug statements here
25515 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
25517 export function ErroringMessageHandler_new(): number {
25518 if(!isWasmInitialized) {
25519 throw new Error("initializeWasm() must be awaited first!");
25521 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
25522 return nativeResponseValue;
25524 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
25526 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
25527 if(!isWasmInitialized) {
25528 throw new Error("initializeWasm() must be awaited first!");
25530 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
25531 return nativeResponseValue;
25533 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
25535 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
25536 if(!isWasmInitialized) {
25537 throw new Error("initializeWasm() must be awaited first!");
25539 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
25540 return nativeResponseValue;
25542 // void MessageHandler_free(struct LDKMessageHandler this_obj);
25544 export function MessageHandler_free(this_obj: number): void {
25545 if(!isWasmInitialized) {
25546 throw new Error("initializeWasm() must be awaited first!");
25548 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
25549 // debug statements here
25551 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25553 export function MessageHandler_get_chan_handler(this_ptr: number): number {
25554 if(!isWasmInitialized) {
25555 throw new Error("initializeWasm() must be awaited first!");
25557 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
25558 return nativeResponseValue;
25560 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
25562 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
25563 if(!isWasmInitialized) {
25564 throw new Error("initializeWasm() must be awaited first!");
25566 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
25567 // debug statements here
25569 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25571 export function MessageHandler_get_route_handler(this_ptr: number): number {
25572 if(!isWasmInitialized) {
25573 throw new Error("initializeWasm() must be awaited first!");
25575 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
25576 return nativeResponseValue;
25578 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
25580 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
25581 if(!isWasmInitialized) {
25582 throw new Error("initializeWasm() must be awaited first!");
25584 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
25585 // debug statements here
25587 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
25589 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
25590 if(!isWasmInitialized) {
25591 throw new Error("initializeWasm() must be awaited first!");
25593 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
25594 return nativeResponseValue;
25596 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
25598 export function SocketDescriptor_clone_ptr(arg: number): number {
25599 if(!isWasmInitialized) {
25600 throw new Error("initializeWasm() must be awaited first!");
25602 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
25603 return nativeResponseValue;
25605 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
25607 export function SocketDescriptor_clone(orig: number): number {
25608 if(!isWasmInitialized) {
25609 throw new Error("initializeWasm() must be awaited first!");
25611 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
25612 return nativeResponseValue;
25614 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
25616 export function SocketDescriptor_free(this_ptr: number): void {
25617 if(!isWasmInitialized) {
25618 throw new Error("initializeWasm() must be awaited first!");
25620 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
25621 // debug statements here
25623 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
25625 export function PeerHandleError_free(this_obj: number): void {
25626 if(!isWasmInitialized) {
25627 throw new Error("initializeWasm() must be awaited first!");
25629 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
25630 // debug statements here
25632 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
25634 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
25635 if(!isWasmInitialized) {
25636 throw new Error("initializeWasm() must be awaited first!");
25638 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
25639 return nativeResponseValue;
25641 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
25643 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
25644 if(!isWasmInitialized) {
25645 throw new Error("initializeWasm() must be awaited first!");
25647 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
25648 // debug statements here
25650 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
25652 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
25653 if(!isWasmInitialized) {
25654 throw new Error("initializeWasm() must be awaited first!");
25656 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
25657 return nativeResponseValue;
25659 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
25661 export function PeerHandleError_clone_ptr(arg: number): number {
25662 if(!isWasmInitialized) {
25663 throw new Error("initializeWasm() must be awaited first!");
25665 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
25666 return nativeResponseValue;
25668 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
25670 export function PeerHandleError_clone(orig: number): number {
25671 if(!isWasmInitialized) {
25672 throw new Error("initializeWasm() must be awaited first!");
25674 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
25675 return nativeResponseValue;
25677 // void PeerManager_free(struct LDKPeerManager this_obj);
25679 export function PeerManager_free(this_obj: number): void {
25680 if(!isWasmInitialized) {
25681 throw new Error("initializeWasm() must be awaited first!");
25683 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
25684 // debug statements here
25686 // 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);
25688 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
25689 if(!isWasmInitialized) {
25690 throw new Error("initializeWasm() must be awaited first!");
25692 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
25693 return nativeResponseValue;
25695 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
25697 export function PeerManager_get_peer_node_ids(this_arg: number): number {
25698 if(!isWasmInitialized) {
25699 throw new Error("initializeWasm() must be awaited first!");
25701 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
25702 return nativeResponseValue;
25704 // 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);
25706 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
25707 if(!isWasmInitialized) {
25708 throw new Error("initializeWasm() must be awaited first!");
25710 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
25711 return nativeResponseValue;
25713 // 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);
25715 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
25716 if(!isWasmInitialized) {
25717 throw new Error("initializeWasm() must be awaited first!");
25719 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
25720 return nativeResponseValue;
25722 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25724 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
25725 if(!isWasmInitialized) {
25726 throw new Error("initializeWasm() must be awaited first!");
25728 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
25729 return nativeResponseValue;
25731 // 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);
25733 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
25734 if(!isWasmInitialized) {
25735 throw new Error("initializeWasm() must be awaited first!");
25737 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
25738 return nativeResponseValue;
25740 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
25742 export function PeerManager_process_events(this_arg: number): void {
25743 if(!isWasmInitialized) {
25744 throw new Error("initializeWasm() must be awaited first!");
25746 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
25747 // debug statements here
25749 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25751 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
25752 if(!isWasmInitialized) {
25753 throw new Error("initializeWasm() must be awaited first!");
25755 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
25756 // debug statements here
25758 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
25760 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
25761 if(!isWasmInitialized) {
25762 throw new Error("initializeWasm() must be awaited first!");
25764 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
25765 // debug statements here
25767 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
25769 export function PeerManager_disconnect_all_peers(this_arg: number): void {
25770 if(!isWasmInitialized) {
25771 throw new Error("initializeWasm() must be awaited first!");
25773 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
25774 // debug statements here
25776 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
25778 export function PeerManager_timer_tick_occurred(this_arg: number): void {
25779 if(!isWasmInitialized) {
25780 throw new Error("initializeWasm() must be awaited first!");
25782 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
25783 // debug statements here
25785 // uint64_t htlc_success_tx_weight(bool opt_anchors);
25787 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
25788 if(!isWasmInitialized) {
25789 throw new Error("initializeWasm() must be awaited first!");
25791 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
25792 return nativeResponseValue;
25794 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
25796 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
25797 if(!isWasmInitialized) {
25798 throw new Error("initializeWasm() must be awaited first!");
25800 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
25801 return nativeResponseValue;
25803 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
25805 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
25806 if(!isWasmInitialized) {
25807 throw new Error("initializeWasm() must be awaited first!");
25809 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
25810 return nativeResponseValue;
25812 // 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);
25814 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: number): number {
25815 if(!isWasmInitialized) {
25816 throw new Error("initializeWasm() must be awaited first!");
25818 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25819 return nativeResponseValue;
25821 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
25823 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
25824 if(!isWasmInitialized) {
25825 throw new Error("initializeWasm() must be awaited first!");
25827 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
25828 // debug statements here
25830 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
25832 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
25833 if(!isWasmInitialized) {
25834 throw new Error("initializeWasm() must be awaited first!");
25836 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
25837 return nativeResponseValue;
25839 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
25841 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
25842 if(!isWasmInitialized) {
25843 throw new Error("initializeWasm() must be awaited first!");
25845 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
25846 return nativeResponseValue;
25848 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
25850 export function CounterpartyCommitmentSecrets_new(): number {
25851 if(!isWasmInitialized) {
25852 throw new Error("initializeWasm() must be awaited first!");
25854 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
25855 return nativeResponseValue;
25857 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
25859 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
25860 if(!isWasmInitialized) {
25861 throw new Error("initializeWasm() must be awaited first!");
25863 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25864 return nativeResponseValue;
25866 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25868 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
25869 if(!isWasmInitialized) {
25870 throw new Error("initializeWasm() must be awaited first!");
25872 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25873 return nativeResponseValue;
25875 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25877 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
25878 if(!isWasmInitialized) {
25879 throw new Error("initializeWasm() must be awaited first!");
25881 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25882 return nativeResponseValue;
25884 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25886 export function CounterpartyCommitmentSecrets_write(obj: number): number {
25887 if(!isWasmInitialized) {
25888 throw new Error("initializeWasm() must be awaited first!");
25890 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25891 return nativeResponseValue;
25893 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25895 export function CounterpartyCommitmentSecrets_read(ser: number): number {
25896 if(!isWasmInitialized) {
25897 throw new Error("initializeWasm() must be awaited first!");
25899 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25900 return nativeResponseValue;
25902 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25904 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
25905 if(!isWasmInitialized) {
25906 throw new Error("initializeWasm() must be awaited first!");
25908 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25909 return nativeResponseValue;
25911 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25913 export function derive_public_key(per_commitment_point: number, base_point: number): number {
25914 if(!isWasmInitialized) {
25915 throw new Error("initializeWasm() must be awaited first!");
25917 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25918 return nativeResponseValue;
25920 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25922 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
25923 if(!isWasmInitialized) {
25924 throw new Error("initializeWasm() must be awaited first!");
25926 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25927 return nativeResponseValue;
25929 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25931 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
25932 if(!isWasmInitialized) {
25933 throw new Error("initializeWasm() must be awaited first!");
25935 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25936 return nativeResponseValue;
25938 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25940 export function TxCreationKeys_free(this_obj: number): void {
25941 if(!isWasmInitialized) {
25942 throw new Error("initializeWasm() must be awaited first!");
25944 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25945 // debug statements here
25947 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25949 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
25950 if(!isWasmInitialized) {
25951 throw new Error("initializeWasm() must be awaited first!");
25953 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25954 return nativeResponseValue;
25956 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25958 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
25959 if(!isWasmInitialized) {
25960 throw new Error("initializeWasm() must be awaited first!");
25962 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25963 // debug statements here
25965 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25967 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
25968 if(!isWasmInitialized) {
25969 throw new Error("initializeWasm() must be awaited first!");
25971 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25972 return nativeResponseValue;
25974 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25976 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
25977 if(!isWasmInitialized) {
25978 throw new Error("initializeWasm() must be awaited first!");
25980 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25981 // debug statements here
25983 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25985 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
25986 if(!isWasmInitialized) {
25987 throw new Error("initializeWasm() must be awaited first!");
25989 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25990 return nativeResponseValue;
25992 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25994 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
25995 if(!isWasmInitialized) {
25996 throw new Error("initializeWasm() must be awaited first!");
25998 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
25999 // debug statements here
26001 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
26003 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
26004 if(!isWasmInitialized) {
26005 throw new Error("initializeWasm() must be awaited first!");
26007 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
26008 return nativeResponseValue;
26010 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26012 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
26013 if(!isWasmInitialized) {
26014 throw new Error("initializeWasm() must be awaited first!");
26016 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
26017 // debug statements here
26019 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
26021 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
26022 if(!isWasmInitialized) {
26023 throw new Error("initializeWasm() must be awaited first!");
26025 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
26026 return nativeResponseValue;
26028 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26030 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
26031 if(!isWasmInitialized) {
26032 throw new Error("initializeWasm() must be awaited first!");
26034 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
26035 // debug statements here
26037 // 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);
26039 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): number {
26040 if(!isWasmInitialized) {
26041 throw new Error("initializeWasm() must be awaited first!");
26043 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);
26044 return nativeResponseValue;
26046 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
26048 export function TxCreationKeys_clone_ptr(arg: number): number {
26049 if(!isWasmInitialized) {
26050 throw new Error("initializeWasm() must be awaited first!");
26052 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
26053 return nativeResponseValue;
26055 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
26057 export function TxCreationKeys_clone(orig: number): number {
26058 if(!isWasmInitialized) {
26059 throw new Error("initializeWasm() must be awaited first!");
26061 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
26062 return nativeResponseValue;
26064 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
26066 export function TxCreationKeys_write(obj: number): number {
26067 if(!isWasmInitialized) {
26068 throw new Error("initializeWasm() must be awaited first!");
26070 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
26071 return nativeResponseValue;
26073 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
26075 export function TxCreationKeys_read(ser: number): number {
26076 if(!isWasmInitialized) {
26077 throw new Error("initializeWasm() must be awaited first!");
26079 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
26080 return nativeResponseValue;
26082 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
26084 export function ChannelPublicKeys_free(this_obj: number): void {
26085 if(!isWasmInitialized) {
26086 throw new Error("initializeWasm() must be awaited first!");
26088 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
26089 // debug statements here
26091 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26093 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
26094 if(!isWasmInitialized) {
26095 throw new Error("initializeWasm() must be awaited first!");
26097 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
26098 return nativeResponseValue;
26100 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26102 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
26103 if(!isWasmInitialized) {
26104 throw new Error("initializeWasm() must be awaited first!");
26106 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
26107 // debug statements here
26109 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26111 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
26112 if(!isWasmInitialized) {
26113 throw new Error("initializeWasm() must be awaited first!");
26115 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
26116 return nativeResponseValue;
26118 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26120 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
26121 if(!isWasmInitialized) {
26122 throw new Error("initializeWasm() must be awaited first!");
26124 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
26125 // debug statements here
26127 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26129 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
26130 if(!isWasmInitialized) {
26131 throw new Error("initializeWasm() must be awaited first!");
26133 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
26134 return nativeResponseValue;
26136 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26138 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
26139 if(!isWasmInitialized) {
26140 throw new Error("initializeWasm() must be awaited first!");
26142 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
26143 // debug statements here
26145 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26147 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
26148 if(!isWasmInitialized) {
26149 throw new Error("initializeWasm() must be awaited first!");
26151 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
26152 return nativeResponseValue;
26154 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26156 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
26157 if(!isWasmInitialized) {
26158 throw new Error("initializeWasm() must be awaited first!");
26160 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
26161 // debug statements here
26163 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26165 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
26166 if(!isWasmInitialized) {
26167 throw new Error("initializeWasm() must be awaited first!");
26169 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
26170 return nativeResponseValue;
26172 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26174 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
26175 if(!isWasmInitialized) {
26176 throw new Error("initializeWasm() must be awaited first!");
26178 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
26179 // debug statements here
26181 // 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);
26183 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): number {
26184 if(!isWasmInitialized) {
26185 throw new Error("initializeWasm() must be awaited first!");
26187 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
26188 return nativeResponseValue;
26190 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
26192 export function ChannelPublicKeys_clone_ptr(arg: number): number {
26193 if(!isWasmInitialized) {
26194 throw new Error("initializeWasm() must be awaited first!");
26196 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
26197 return nativeResponseValue;
26199 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
26201 export function ChannelPublicKeys_clone(orig: number): number {
26202 if(!isWasmInitialized) {
26203 throw new Error("initializeWasm() must be awaited first!");
26205 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
26206 return nativeResponseValue;
26208 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
26210 export function ChannelPublicKeys_write(obj: number): number {
26211 if(!isWasmInitialized) {
26212 throw new Error("initializeWasm() must be awaited first!");
26214 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
26215 return nativeResponseValue;
26217 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
26219 export function ChannelPublicKeys_read(ser: number): number {
26220 if(!isWasmInitialized) {
26221 throw new Error("initializeWasm() must be awaited first!");
26223 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
26224 return nativeResponseValue;
26226 // 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);
26228 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): number {
26229 if(!isWasmInitialized) {
26230 throw new Error("initializeWasm() must be awaited first!");
26232 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
26233 return nativeResponseValue;
26235 // 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);
26237 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
26238 if(!isWasmInitialized) {
26239 throw new Error("initializeWasm() must be awaited first!");
26241 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
26242 return nativeResponseValue;
26244 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
26246 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
26247 if(!isWasmInitialized) {
26248 throw new Error("initializeWasm() must be awaited first!");
26250 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
26251 return nativeResponseValue;
26253 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
26255 export function HTLCOutputInCommitment_free(this_obj: number): void {
26256 if(!isWasmInitialized) {
26257 throw new Error("initializeWasm() must be awaited first!");
26259 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
26260 // debug statements here
26262 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26264 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
26265 if(!isWasmInitialized) {
26266 throw new Error("initializeWasm() must be awaited first!");
26268 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
26269 return nativeResponseValue;
26271 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
26273 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
26274 if(!isWasmInitialized) {
26275 throw new Error("initializeWasm() must be awaited first!");
26277 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
26278 // debug statements here
26280 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26282 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
26283 if(!isWasmInitialized) {
26284 throw new Error("initializeWasm() must be awaited first!");
26286 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
26287 return nativeResponseValue;
26289 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
26291 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
26292 if(!isWasmInitialized) {
26293 throw new Error("initializeWasm() must be awaited first!");
26295 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
26296 // debug statements here
26298 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26300 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
26301 if(!isWasmInitialized) {
26302 throw new Error("initializeWasm() must be awaited first!");
26304 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
26305 return nativeResponseValue;
26307 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
26309 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
26310 if(!isWasmInitialized) {
26311 throw new Error("initializeWasm() must be awaited first!");
26313 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
26314 // debug statements here
26316 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
26318 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
26319 if(!isWasmInitialized) {
26320 throw new Error("initializeWasm() must be awaited first!");
26322 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
26323 return nativeResponseValue;
26325 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26327 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
26328 if(!isWasmInitialized) {
26329 throw new Error("initializeWasm() must be awaited first!");
26331 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
26332 // debug statements here
26334 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26336 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
26337 if(!isWasmInitialized) {
26338 throw new Error("initializeWasm() must be awaited first!");
26340 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
26341 return nativeResponseValue;
26343 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26345 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
26346 if(!isWasmInitialized) {
26347 throw new Error("initializeWasm() must be awaited first!");
26349 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
26350 // debug statements here
26352 // 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);
26354 export function HTLCOutputInCommitment_new(offered_arg: boolean, amount_msat_arg: bigint, cltv_expiry_arg: number, payment_hash_arg: number, transaction_output_index_arg: number): number {
26355 if(!isWasmInitialized) {
26356 throw new Error("initializeWasm() must be awaited first!");
26358 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
26359 return nativeResponseValue;
26361 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
26363 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
26364 if(!isWasmInitialized) {
26365 throw new Error("initializeWasm() must be awaited first!");
26367 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
26368 return nativeResponseValue;
26370 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
26372 export function HTLCOutputInCommitment_clone(orig: number): number {
26373 if(!isWasmInitialized) {
26374 throw new Error("initializeWasm() must be awaited first!");
26376 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
26377 return nativeResponseValue;
26379 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
26381 export function HTLCOutputInCommitment_write(obj: number): number {
26382 if(!isWasmInitialized) {
26383 throw new Error("initializeWasm() must be awaited first!");
26385 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
26386 return nativeResponseValue;
26388 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
26390 export function HTLCOutputInCommitment_read(ser: number): number {
26391 if(!isWasmInitialized) {
26392 throw new Error("initializeWasm() must be awaited first!");
26394 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
26395 return nativeResponseValue;
26397 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
26399 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
26400 if(!isWasmInitialized) {
26401 throw new Error("initializeWasm() must be awaited first!");
26403 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
26404 return nativeResponseValue;
26406 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
26408 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
26409 if(!isWasmInitialized) {
26410 throw new Error("initializeWasm() must be awaited first!");
26412 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
26413 return nativeResponseValue;
26415 // 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);
26417 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: number, opt_anchors: boolean, broadcaster_delayed_payment_key: number, revocation_key: number): number {
26418 if(!isWasmInitialized) {
26419 throw new Error("initializeWasm() must be awaited first!");
26421 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
26422 return nativeResponseValue;
26424 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
26426 export function get_anchor_redeemscript(funding_pubkey: number): number {
26427 if(!isWasmInitialized) {
26428 throw new Error("initializeWasm() must be awaited first!");
26430 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
26431 return nativeResponseValue;
26433 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
26435 export function ChannelTransactionParameters_free(this_obj: number): void {
26436 if(!isWasmInitialized) {
26437 throw new Error("initializeWasm() must be awaited first!");
26439 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
26440 // debug statements here
26442 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26444 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
26445 if(!isWasmInitialized) {
26446 throw new Error("initializeWasm() must be awaited first!");
26448 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
26449 return nativeResponseValue;
26451 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26453 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
26454 if(!isWasmInitialized) {
26455 throw new Error("initializeWasm() must be awaited first!");
26457 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
26458 // debug statements here
26460 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26462 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
26463 if(!isWasmInitialized) {
26464 throw new Error("initializeWasm() must be awaited first!");
26466 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
26467 return nativeResponseValue;
26469 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26471 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
26472 if(!isWasmInitialized) {
26473 throw new Error("initializeWasm() must be awaited first!");
26475 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
26476 // debug statements here
26478 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26480 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
26481 if(!isWasmInitialized) {
26482 throw new Error("initializeWasm() must be awaited first!");
26484 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
26485 return nativeResponseValue;
26487 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
26489 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
26490 if(!isWasmInitialized) {
26491 throw new Error("initializeWasm() must be awaited first!");
26493 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
26494 // debug statements here
26496 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26498 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
26499 if(!isWasmInitialized) {
26500 throw new Error("initializeWasm() must be awaited first!");
26502 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
26503 return nativeResponseValue;
26505 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
26507 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
26508 if(!isWasmInitialized) {
26509 throw new Error("initializeWasm() must be awaited first!");
26511 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
26512 // debug statements here
26514 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26516 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
26517 if(!isWasmInitialized) {
26518 throw new Error("initializeWasm() must be awaited first!");
26520 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
26521 return nativeResponseValue;
26523 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
26525 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
26526 if(!isWasmInitialized) {
26527 throw new Error("initializeWasm() must be awaited first!");
26529 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
26530 // debug statements here
26532 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26534 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
26535 if(!isWasmInitialized) {
26536 throw new Error("initializeWasm() must be awaited first!");
26538 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
26539 return nativeResponseValue;
26541 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
26543 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
26544 if(!isWasmInitialized) {
26545 throw new Error("initializeWasm() must be awaited first!");
26547 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
26548 // debug statements here
26550 // 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);
26552 export function ChannelTransactionParameters_new(holder_pubkeys_arg: number, holder_selected_contest_delay_arg: number, is_outbound_from_holder_arg: boolean, counterparty_parameters_arg: number, funding_outpoint_arg: number, opt_anchors_arg: COption_NoneZ): number {
26553 if(!isWasmInitialized) {
26554 throw new Error("initializeWasm() must be awaited first!");
26556 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);
26557 return nativeResponseValue;
26559 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
26561 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
26562 if(!isWasmInitialized) {
26563 throw new Error("initializeWasm() must be awaited first!");
26565 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
26566 return nativeResponseValue;
26568 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
26570 export function ChannelTransactionParameters_clone(orig: number): number {
26571 if(!isWasmInitialized) {
26572 throw new Error("initializeWasm() must be awaited first!");
26574 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
26575 return nativeResponseValue;
26577 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
26579 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
26580 if(!isWasmInitialized) {
26581 throw new Error("initializeWasm() must be awaited first!");
26583 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
26584 // debug statements here
26586 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26588 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
26589 if(!isWasmInitialized) {
26590 throw new Error("initializeWasm() must be awaited first!");
26592 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
26593 return nativeResponseValue;
26595 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26597 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
26598 if(!isWasmInitialized) {
26599 throw new Error("initializeWasm() must be awaited first!");
26601 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
26602 // debug statements here
26604 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26606 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
26607 if(!isWasmInitialized) {
26608 throw new Error("initializeWasm() must be awaited first!");
26610 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
26611 return nativeResponseValue;
26613 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26615 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
26616 if(!isWasmInitialized) {
26617 throw new Error("initializeWasm() must be awaited first!");
26619 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
26620 // debug statements here
26622 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
26624 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
26625 if(!isWasmInitialized) {
26626 throw new Error("initializeWasm() must be awaited first!");
26628 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
26629 return nativeResponseValue;
26631 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
26633 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
26634 if(!isWasmInitialized) {
26635 throw new Error("initializeWasm() must be awaited first!");
26637 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
26638 return nativeResponseValue;
26640 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
26642 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
26643 if(!isWasmInitialized) {
26644 throw new Error("initializeWasm() must be awaited first!");
26646 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
26647 return nativeResponseValue;
26649 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26651 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
26652 if(!isWasmInitialized) {
26653 throw new Error("initializeWasm() must be awaited first!");
26655 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
26656 return nativeResponseValue;
26658 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26660 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
26661 if(!isWasmInitialized) {
26662 throw new Error("initializeWasm() must be awaited first!");
26664 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
26665 return nativeResponseValue;
26667 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26669 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
26670 if(!isWasmInitialized) {
26671 throw new Error("initializeWasm() must be awaited first!");
26673 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
26674 return nativeResponseValue;
26676 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
26678 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
26679 if(!isWasmInitialized) {
26680 throw new Error("initializeWasm() must be awaited first!");
26682 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
26683 return nativeResponseValue;
26685 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
26687 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
26688 if(!isWasmInitialized) {
26689 throw new Error("initializeWasm() must be awaited first!");
26691 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
26692 return nativeResponseValue;
26694 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
26696 export function ChannelTransactionParameters_write(obj: number): number {
26697 if(!isWasmInitialized) {
26698 throw new Error("initializeWasm() must be awaited first!");
26700 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
26701 return nativeResponseValue;
26703 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
26705 export function ChannelTransactionParameters_read(ser: number): number {
26706 if(!isWasmInitialized) {
26707 throw new Error("initializeWasm() must be awaited first!");
26709 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
26710 return nativeResponseValue;
26712 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
26714 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
26715 if(!isWasmInitialized) {
26716 throw new Error("initializeWasm() must be awaited first!");
26718 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
26719 // debug statements here
26721 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26723 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
26724 if(!isWasmInitialized) {
26725 throw new Error("initializeWasm() must be awaited first!");
26727 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
26728 return nativeResponseValue;
26730 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26732 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
26733 if(!isWasmInitialized) {
26734 throw new Error("initializeWasm() must be awaited first!");
26736 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
26737 return nativeResponseValue;
26739 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26741 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
26742 if(!isWasmInitialized) {
26743 throw new Error("initializeWasm() must be awaited first!");
26745 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
26746 return nativeResponseValue;
26748 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26750 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
26751 if(!isWasmInitialized) {
26752 throw new Error("initializeWasm() must be awaited first!");
26754 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
26755 return nativeResponseValue;
26757 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26759 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
26760 if(!isWasmInitialized) {
26761 throw new Error("initializeWasm() must be awaited first!");
26763 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
26764 return nativeResponseValue;
26766 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26768 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
26769 if(!isWasmInitialized) {
26770 throw new Error("initializeWasm() must be awaited first!");
26772 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
26773 return nativeResponseValue;
26775 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
26777 export function HolderCommitmentTransaction_free(this_obj: number): void {
26778 if(!isWasmInitialized) {
26779 throw new Error("initializeWasm() must be awaited first!");
26781 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
26782 // debug statements here
26784 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26786 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
26787 if(!isWasmInitialized) {
26788 throw new Error("initializeWasm() must be awaited first!");
26790 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
26791 return nativeResponseValue;
26793 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
26795 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
26796 if(!isWasmInitialized) {
26797 throw new Error("initializeWasm() must be awaited first!");
26799 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
26800 // debug statements here
26802 // struct LDKCVec_SignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26804 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: number): number {
26805 if(!isWasmInitialized) {
26806 throw new Error("initializeWasm() must be awaited first!");
26808 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
26809 return nativeResponseValue;
26811 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
26813 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
26814 if(!isWasmInitialized) {
26815 throw new Error("initializeWasm() must be awaited first!");
26817 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
26818 // debug statements here
26820 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
26822 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
26823 if(!isWasmInitialized) {
26824 throw new Error("initializeWasm() must be awaited first!");
26826 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
26827 return nativeResponseValue;
26829 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
26831 export function HolderCommitmentTransaction_clone(orig: number): number {
26832 if(!isWasmInitialized) {
26833 throw new Error("initializeWasm() must be awaited first!");
26835 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
26836 return nativeResponseValue;
26838 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
26840 export function HolderCommitmentTransaction_write(obj: number): number {
26841 if(!isWasmInitialized) {
26842 throw new Error("initializeWasm() must be awaited first!");
26844 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
26845 return nativeResponseValue;
26847 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
26849 export function HolderCommitmentTransaction_read(ser: number): number {
26850 if(!isWasmInitialized) {
26851 throw new Error("initializeWasm() must be awaited first!");
26853 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
26854 return nativeResponseValue;
26856 // 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);
26858 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
26859 if(!isWasmInitialized) {
26860 throw new Error("initializeWasm() must be awaited first!");
26862 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
26863 return nativeResponseValue;
26865 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
26867 export function BuiltCommitmentTransaction_free(this_obj: number): void {
26868 if(!isWasmInitialized) {
26869 throw new Error("initializeWasm() must be awaited first!");
26871 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
26872 // debug statements here
26874 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26876 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
26877 if(!isWasmInitialized) {
26878 throw new Error("initializeWasm() must be awaited first!");
26880 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26881 return nativeResponseValue;
26883 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26885 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
26886 if(!isWasmInitialized) {
26887 throw new Error("initializeWasm() must be awaited first!");
26889 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26890 // debug statements here
26892 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26894 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
26895 if(!isWasmInitialized) {
26896 throw new Error("initializeWasm() must be awaited first!");
26898 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26899 return nativeResponseValue;
26901 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26903 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
26904 if(!isWasmInitialized) {
26905 throw new Error("initializeWasm() must be awaited first!");
26907 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26908 // debug statements here
26910 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26912 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
26913 if(!isWasmInitialized) {
26914 throw new Error("initializeWasm() must be awaited first!");
26916 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26917 return nativeResponseValue;
26919 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26921 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
26922 if(!isWasmInitialized) {
26923 throw new Error("initializeWasm() must be awaited first!");
26925 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26926 return nativeResponseValue;
26928 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26930 export function BuiltCommitmentTransaction_clone(orig: number): number {
26931 if(!isWasmInitialized) {
26932 throw new Error("initializeWasm() must be awaited first!");
26934 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26935 return nativeResponseValue;
26937 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26939 export function BuiltCommitmentTransaction_write(obj: number): number {
26940 if(!isWasmInitialized) {
26941 throw new Error("initializeWasm() must be awaited first!");
26943 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26944 return nativeResponseValue;
26946 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26948 export function BuiltCommitmentTransaction_read(ser: number): number {
26949 if(!isWasmInitialized) {
26950 throw new Error("initializeWasm() must be awaited first!");
26952 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26953 return nativeResponseValue;
26955 // 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);
26957 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26958 if(!isWasmInitialized) {
26959 throw new Error("initializeWasm() must be awaited first!");
26961 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26962 return nativeResponseValue;
26964 // 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);
26966 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26967 if(!isWasmInitialized) {
26968 throw new Error("initializeWasm() must be awaited first!");
26970 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26971 return nativeResponseValue;
26973 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26975 export function ClosingTransaction_free(this_obj: number): void {
26976 if(!isWasmInitialized) {
26977 throw new Error("initializeWasm() must be awaited first!");
26979 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26980 // debug statements here
26982 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26984 export function ClosingTransaction_clone_ptr(arg: number): number {
26985 if(!isWasmInitialized) {
26986 throw new Error("initializeWasm() must be awaited first!");
26988 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26989 return nativeResponseValue;
26991 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
26993 export function ClosingTransaction_clone(orig: number): number {
26994 if(!isWasmInitialized) {
26995 throw new Error("initializeWasm() must be awaited first!");
26997 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
26998 return nativeResponseValue;
27000 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
27002 export function ClosingTransaction_hash(o: number): bigint {
27003 if(!isWasmInitialized) {
27004 throw new Error("initializeWasm() must be awaited first!");
27006 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
27007 return nativeResponseValue;
27009 // 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);
27011 export function ClosingTransaction_new(to_holder_value_sat: bigint, to_counterparty_value_sat: bigint, to_holder_script: number, to_counterparty_script: number, funding_outpoint: number): number {
27012 if(!isWasmInitialized) {
27013 throw new Error("initializeWasm() must be awaited first!");
27015 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
27016 return nativeResponseValue;
27018 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27020 export function ClosingTransaction_trust(this_arg: number): number {
27021 if(!isWasmInitialized) {
27022 throw new Error("initializeWasm() must be awaited first!");
27024 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
27025 return nativeResponseValue;
27027 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
27029 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
27030 if(!isWasmInitialized) {
27031 throw new Error("initializeWasm() must be awaited first!");
27033 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
27034 return nativeResponseValue;
27036 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27038 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
27039 if(!isWasmInitialized) {
27040 throw new Error("initializeWasm() must be awaited first!");
27042 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
27043 return nativeResponseValue;
27045 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27047 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
27048 if(!isWasmInitialized) {
27049 throw new Error("initializeWasm() must be awaited first!");
27051 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
27052 return nativeResponseValue;
27054 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27056 export function ClosingTransaction_to_holder_script(this_arg: number): number {
27057 if(!isWasmInitialized) {
27058 throw new Error("initializeWasm() must be awaited first!");
27060 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
27061 return nativeResponseValue;
27063 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
27065 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
27066 if(!isWasmInitialized) {
27067 throw new Error("initializeWasm() must be awaited first!");
27069 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
27070 return nativeResponseValue;
27072 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
27074 export function TrustedClosingTransaction_free(this_obj: number): void {
27075 if(!isWasmInitialized) {
27076 throw new Error("initializeWasm() must be awaited first!");
27078 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
27079 // debug statements here
27081 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
27083 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
27084 if(!isWasmInitialized) {
27085 throw new Error("initializeWasm() must be awaited first!");
27087 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
27088 return nativeResponseValue;
27090 // 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);
27092 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
27093 if(!isWasmInitialized) {
27094 throw new Error("initializeWasm() must be awaited first!");
27096 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
27097 return nativeResponseValue;
27099 // 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);
27101 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
27102 if(!isWasmInitialized) {
27103 throw new Error("initializeWasm() must be awaited first!");
27105 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
27106 return nativeResponseValue;
27108 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
27110 export function CommitmentTransaction_free(this_obj: number): void {
27111 if(!isWasmInitialized) {
27112 throw new Error("initializeWasm() must be awaited first!");
27114 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
27115 // debug statements here
27117 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
27119 export function CommitmentTransaction_clone_ptr(arg: number): number {
27120 if(!isWasmInitialized) {
27121 throw new Error("initializeWasm() must be awaited first!");
27123 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
27124 return nativeResponseValue;
27126 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
27128 export function CommitmentTransaction_clone(orig: number): number {
27129 if(!isWasmInitialized) {
27130 throw new Error("initializeWasm() must be awaited first!");
27132 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
27133 return nativeResponseValue;
27135 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
27137 export function CommitmentTransaction_write(obj: number): number {
27138 if(!isWasmInitialized) {
27139 throw new Error("initializeWasm() must be awaited first!");
27141 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
27142 return nativeResponseValue;
27144 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
27146 export function CommitmentTransaction_read(ser: number): number {
27147 if(!isWasmInitialized) {
27148 throw new Error("initializeWasm() must be awaited first!");
27150 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
27151 return nativeResponseValue;
27153 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27155 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
27156 if(!isWasmInitialized) {
27157 throw new Error("initializeWasm() must be awaited first!");
27159 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
27160 return nativeResponseValue;
27162 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27164 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
27165 if(!isWasmInitialized) {
27166 throw new Error("initializeWasm() must be awaited first!");
27168 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
27169 return nativeResponseValue;
27171 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27173 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
27174 if(!isWasmInitialized) {
27175 throw new Error("initializeWasm() must be awaited first!");
27177 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
27178 return nativeResponseValue;
27180 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27182 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
27183 if(!isWasmInitialized) {
27184 throw new Error("initializeWasm() must be awaited first!");
27186 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
27187 return nativeResponseValue;
27189 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27191 export function CommitmentTransaction_trust(this_arg: number): number {
27192 if(!isWasmInitialized) {
27193 throw new Error("initializeWasm() must be awaited first!");
27195 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
27196 return nativeResponseValue;
27198 // 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);
27200 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
27201 if(!isWasmInitialized) {
27202 throw new Error("initializeWasm() must be awaited first!");
27204 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
27205 return nativeResponseValue;
27207 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
27209 export function TrustedCommitmentTransaction_free(this_obj: number): void {
27210 if(!isWasmInitialized) {
27211 throw new Error("initializeWasm() must be awaited first!");
27213 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
27214 // debug statements here
27216 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27218 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
27219 if(!isWasmInitialized) {
27220 throw new Error("initializeWasm() must be awaited first!");
27222 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
27223 return nativeResponseValue;
27225 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27227 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
27228 if(!isWasmInitialized) {
27229 throw new Error("initializeWasm() must be awaited first!");
27231 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
27232 return nativeResponseValue;
27234 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27236 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
27237 if(!isWasmInitialized) {
27238 throw new Error("initializeWasm() must be awaited first!");
27240 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
27241 return nativeResponseValue;
27243 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27245 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
27246 if(!isWasmInitialized) {
27247 throw new Error("initializeWasm() must be awaited first!");
27249 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
27250 return nativeResponseValue;
27252 // 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);
27254 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
27255 if(!isWasmInitialized) {
27256 throw new Error("initializeWasm() must be awaited first!");
27258 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
27259 return nativeResponseValue;
27261 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
27263 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
27264 if(!isWasmInitialized) {
27265 throw new Error("initializeWasm() must be awaited first!");
27267 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
27268 return nativeResponseValue;
27270 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
27272 export function InitFeatures_eq(a: number, b: number): boolean {
27273 if(!isWasmInitialized) {
27274 throw new Error("initializeWasm() must be awaited first!");
27276 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
27277 return nativeResponseValue;
27279 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
27281 export function NodeFeatures_eq(a: number, b: number): boolean {
27282 if(!isWasmInitialized) {
27283 throw new Error("initializeWasm() must be awaited first!");
27285 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
27286 return nativeResponseValue;
27288 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
27290 export function ChannelFeatures_eq(a: number, b: number): boolean {
27291 if(!isWasmInitialized) {
27292 throw new Error("initializeWasm() must be awaited first!");
27294 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
27295 return nativeResponseValue;
27297 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
27299 export function InvoiceFeatures_eq(a: number, b: number): boolean {
27300 if(!isWasmInitialized) {
27301 throw new Error("initializeWasm() must be awaited first!");
27303 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
27304 return nativeResponseValue;
27306 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
27308 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
27309 if(!isWasmInitialized) {
27310 throw new Error("initializeWasm() must be awaited first!");
27312 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
27313 return nativeResponseValue;
27315 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
27317 export function InitFeatures_clone_ptr(arg: number): number {
27318 if(!isWasmInitialized) {
27319 throw new Error("initializeWasm() must be awaited first!");
27321 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
27322 return nativeResponseValue;
27324 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
27326 export function InitFeatures_clone(orig: number): number {
27327 if(!isWasmInitialized) {
27328 throw new Error("initializeWasm() must be awaited first!");
27330 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
27331 return nativeResponseValue;
27333 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
27335 export function NodeFeatures_clone_ptr(arg: number): number {
27336 if(!isWasmInitialized) {
27337 throw new Error("initializeWasm() must be awaited first!");
27339 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
27340 return nativeResponseValue;
27342 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
27344 export function NodeFeatures_clone(orig: number): number {
27345 if(!isWasmInitialized) {
27346 throw new Error("initializeWasm() must be awaited first!");
27348 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
27349 return nativeResponseValue;
27351 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
27353 export function ChannelFeatures_clone_ptr(arg: number): number {
27354 if(!isWasmInitialized) {
27355 throw new Error("initializeWasm() must be awaited first!");
27357 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
27358 return nativeResponseValue;
27360 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
27362 export function ChannelFeatures_clone(orig: number): number {
27363 if(!isWasmInitialized) {
27364 throw new Error("initializeWasm() must be awaited first!");
27366 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
27367 return nativeResponseValue;
27369 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
27371 export function InvoiceFeatures_clone_ptr(arg: number): number {
27372 if(!isWasmInitialized) {
27373 throw new Error("initializeWasm() must be awaited first!");
27375 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
27376 return nativeResponseValue;
27378 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
27380 export function InvoiceFeatures_clone(orig: number): number {
27381 if(!isWasmInitialized) {
27382 throw new Error("initializeWasm() must be awaited first!");
27384 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
27385 return nativeResponseValue;
27387 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
27389 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
27390 if(!isWasmInitialized) {
27391 throw new Error("initializeWasm() must be awaited first!");
27393 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
27394 return nativeResponseValue;
27396 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
27398 export function ChannelTypeFeatures_clone(orig: number): number {
27399 if(!isWasmInitialized) {
27400 throw new Error("initializeWasm() must be awaited first!");
27402 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
27403 return nativeResponseValue;
27405 // void InitFeatures_free(struct LDKInitFeatures this_obj);
27407 export function InitFeatures_free(this_obj: number): void {
27408 if(!isWasmInitialized) {
27409 throw new Error("initializeWasm() must be awaited first!");
27411 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
27412 // debug statements here
27414 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
27416 export function NodeFeatures_free(this_obj: number): void {
27417 if(!isWasmInitialized) {
27418 throw new Error("initializeWasm() must be awaited first!");
27420 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
27421 // debug statements here
27423 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
27425 export function ChannelFeatures_free(this_obj: number): void {
27426 if(!isWasmInitialized) {
27427 throw new Error("initializeWasm() must be awaited first!");
27429 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
27430 // debug statements here
27432 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
27434 export function InvoiceFeatures_free(this_obj: number): void {
27435 if(!isWasmInitialized) {
27436 throw new Error("initializeWasm() must be awaited first!");
27438 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
27439 // debug statements here
27441 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
27443 export function ChannelTypeFeatures_free(this_obj: number): void {
27444 if(!isWasmInitialized) {
27445 throw new Error("initializeWasm() must be awaited first!");
27447 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
27448 // debug statements here
27450 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
27452 export function InitFeatures_empty(): number {
27453 if(!isWasmInitialized) {
27454 throw new Error("initializeWasm() must be awaited first!");
27456 const nativeResponseValue = wasm.TS_InitFeatures_empty();
27457 return nativeResponseValue;
27459 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
27461 export function InitFeatures_known(): number {
27462 if(!isWasmInitialized) {
27463 throw new Error("initializeWasm() must be awaited first!");
27465 const nativeResponseValue = wasm.TS_InitFeatures_known();
27466 return nativeResponseValue;
27468 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27470 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
27471 if(!isWasmInitialized) {
27472 throw new Error("initializeWasm() must be awaited first!");
27474 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
27475 return nativeResponseValue;
27477 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
27479 export function NodeFeatures_empty(): number {
27480 if(!isWasmInitialized) {
27481 throw new Error("initializeWasm() must be awaited first!");
27483 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
27484 return nativeResponseValue;
27486 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
27488 export function NodeFeatures_known(): number {
27489 if(!isWasmInitialized) {
27490 throw new Error("initializeWasm() must be awaited first!");
27492 const nativeResponseValue = wasm.TS_NodeFeatures_known();
27493 return nativeResponseValue;
27495 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27497 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
27498 if(!isWasmInitialized) {
27499 throw new Error("initializeWasm() must be awaited first!");
27501 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
27502 return nativeResponseValue;
27504 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
27506 export function ChannelFeatures_empty(): number {
27507 if(!isWasmInitialized) {
27508 throw new Error("initializeWasm() must be awaited first!");
27510 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
27511 return nativeResponseValue;
27513 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
27515 export function ChannelFeatures_known(): number {
27516 if(!isWasmInitialized) {
27517 throw new Error("initializeWasm() must be awaited first!");
27519 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
27520 return nativeResponseValue;
27522 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
27524 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
27525 if(!isWasmInitialized) {
27526 throw new Error("initializeWasm() must be awaited first!");
27528 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
27529 return nativeResponseValue;
27531 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
27533 export function InvoiceFeatures_empty(): number {
27534 if(!isWasmInitialized) {
27535 throw new Error("initializeWasm() must be awaited first!");
27537 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
27538 return nativeResponseValue;
27540 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
27542 export function InvoiceFeatures_known(): number {
27543 if(!isWasmInitialized) {
27544 throw new Error("initializeWasm() must be awaited first!");
27546 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
27547 return nativeResponseValue;
27549 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27551 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
27552 if(!isWasmInitialized) {
27553 throw new Error("initializeWasm() must be awaited first!");
27555 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
27556 return nativeResponseValue;
27558 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
27560 export function ChannelTypeFeatures_empty(): number {
27561 if(!isWasmInitialized) {
27562 throw new Error("initializeWasm() must be awaited first!");
27564 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
27565 return nativeResponseValue;
27567 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
27569 export function ChannelTypeFeatures_known(): number {
27570 if(!isWasmInitialized) {
27571 throw new Error("initializeWasm() must be awaited first!");
27573 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
27574 return nativeResponseValue;
27576 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27578 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
27579 if(!isWasmInitialized) {
27580 throw new Error("initializeWasm() must be awaited first!");
27582 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
27583 return nativeResponseValue;
27585 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
27587 export function InitFeatures_write(obj: number): number {
27588 if(!isWasmInitialized) {
27589 throw new Error("initializeWasm() must be awaited first!");
27591 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
27592 return nativeResponseValue;
27594 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
27596 export function InitFeatures_read(ser: number): number {
27597 if(!isWasmInitialized) {
27598 throw new Error("initializeWasm() must be awaited first!");
27600 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
27601 return nativeResponseValue;
27603 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
27605 export function ChannelFeatures_write(obj: number): number {
27606 if(!isWasmInitialized) {
27607 throw new Error("initializeWasm() must be awaited first!");
27609 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
27610 return nativeResponseValue;
27612 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
27614 export function ChannelFeatures_read(ser: number): number {
27615 if(!isWasmInitialized) {
27616 throw new Error("initializeWasm() must be awaited first!");
27618 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
27619 return nativeResponseValue;
27621 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
27623 export function NodeFeatures_write(obj: number): number {
27624 if(!isWasmInitialized) {
27625 throw new Error("initializeWasm() must be awaited first!");
27627 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
27628 return nativeResponseValue;
27630 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
27632 export function NodeFeatures_read(ser: number): number {
27633 if(!isWasmInitialized) {
27634 throw new Error("initializeWasm() must be awaited first!");
27636 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
27637 return nativeResponseValue;
27639 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
27641 export function InvoiceFeatures_write(obj: number): number {
27642 if(!isWasmInitialized) {
27643 throw new Error("initializeWasm() must be awaited first!");
27645 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
27646 return nativeResponseValue;
27648 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
27650 export function InvoiceFeatures_read(ser: number): number {
27651 if(!isWasmInitialized) {
27652 throw new Error("initializeWasm() must be awaited first!");
27654 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
27655 return nativeResponseValue;
27657 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
27659 export function ChannelTypeFeatures_write(obj: number): number {
27660 if(!isWasmInitialized) {
27661 throw new Error("initializeWasm() must be awaited first!");
27663 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
27664 return nativeResponseValue;
27666 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
27668 export function ChannelTypeFeatures_read(ser: number): number {
27669 if(!isWasmInitialized) {
27670 throw new Error("initializeWasm() must be awaited first!");
27672 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
27673 return nativeResponseValue;
27675 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27677 export function InitFeatures_set_data_loss_protect_optional(this_arg: number): void {
27678 if(!isWasmInitialized) {
27679 throw new Error("initializeWasm() must be awaited first!");
27681 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
27682 // debug statements here
27684 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27686 export function InitFeatures_set_data_loss_protect_required(this_arg: number): void {
27687 if(!isWasmInitialized) {
27688 throw new Error("initializeWasm() must be awaited first!");
27690 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
27691 // debug statements here
27693 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27695 export function InitFeatures_supports_data_loss_protect(this_arg: number): boolean {
27696 if(!isWasmInitialized) {
27697 throw new Error("initializeWasm() must be awaited first!");
27699 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
27700 return nativeResponseValue;
27702 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27704 export function NodeFeatures_set_data_loss_protect_optional(this_arg: number): void {
27705 if(!isWasmInitialized) {
27706 throw new Error("initializeWasm() must be awaited first!");
27708 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
27709 // debug statements here
27711 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27713 export function NodeFeatures_set_data_loss_protect_required(this_arg: number): void {
27714 if(!isWasmInitialized) {
27715 throw new Error("initializeWasm() must be awaited first!");
27717 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
27718 // debug statements here
27720 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27722 export function NodeFeatures_supports_data_loss_protect(this_arg: number): boolean {
27723 if(!isWasmInitialized) {
27724 throw new Error("initializeWasm() must be awaited first!");
27726 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
27727 return nativeResponseValue;
27729 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27731 export function InitFeatures_requires_data_loss_protect(this_arg: number): boolean {
27732 if(!isWasmInitialized) {
27733 throw new Error("initializeWasm() must be awaited first!");
27735 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
27736 return nativeResponseValue;
27738 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27740 export function NodeFeatures_requires_data_loss_protect(this_arg: number): boolean {
27741 if(!isWasmInitialized) {
27742 throw new Error("initializeWasm() must be awaited first!");
27744 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
27745 return nativeResponseValue;
27747 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27749 export function InitFeatures_set_initial_routing_sync_optional(this_arg: number): void {
27750 if(!isWasmInitialized) {
27751 throw new Error("initializeWasm() must be awaited first!");
27753 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
27754 // debug statements here
27756 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27758 export function InitFeatures_set_initial_routing_sync_required(this_arg: number): void {
27759 if(!isWasmInitialized) {
27760 throw new Error("initializeWasm() must be awaited first!");
27762 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
27763 // debug statements here
27765 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27767 export function InitFeatures_initial_routing_sync(this_arg: number): boolean {
27768 if(!isWasmInitialized) {
27769 throw new Error("initializeWasm() must be awaited first!");
27771 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
27772 return nativeResponseValue;
27774 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27776 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27777 if(!isWasmInitialized) {
27778 throw new Error("initializeWasm() must be awaited first!");
27780 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
27781 // debug statements here
27783 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27785 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27786 if(!isWasmInitialized) {
27787 throw new Error("initializeWasm() must be awaited first!");
27789 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
27790 // debug statements here
27792 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27794 export function InitFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27795 if(!isWasmInitialized) {
27796 throw new Error("initializeWasm() must be awaited first!");
27798 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
27799 return nativeResponseValue;
27801 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27803 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27804 if(!isWasmInitialized) {
27805 throw new Error("initializeWasm() must be awaited first!");
27807 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
27808 // debug statements here
27810 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27812 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27813 if(!isWasmInitialized) {
27814 throw new Error("initializeWasm() must be awaited first!");
27816 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
27817 // debug statements here
27819 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27821 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27822 if(!isWasmInitialized) {
27823 throw new Error("initializeWasm() must be awaited first!");
27825 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
27826 return nativeResponseValue;
27828 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27830 export function InitFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27831 if(!isWasmInitialized) {
27832 throw new Error("initializeWasm() must be awaited first!");
27834 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
27835 return nativeResponseValue;
27837 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27839 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27840 if(!isWasmInitialized) {
27841 throw new Error("initializeWasm() must be awaited first!");
27843 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
27844 return nativeResponseValue;
27846 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27848 export function InitFeatures_set_gossip_queries_optional(this_arg: number): void {
27849 if(!isWasmInitialized) {
27850 throw new Error("initializeWasm() must be awaited first!");
27852 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
27853 // debug statements here
27855 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27857 export function InitFeatures_set_gossip_queries_required(this_arg: number): void {
27858 if(!isWasmInitialized) {
27859 throw new Error("initializeWasm() must be awaited first!");
27861 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
27862 // debug statements here
27864 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27866 export function InitFeatures_supports_gossip_queries(this_arg: number): boolean {
27867 if(!isWasmInitialized) {
27868 throw new Error("initializeWasm() must be awaited first!");
27870 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
27871 return nativeResponseValue;
27873 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27875 export function NodeFeatures_set_gossip_queries_optional(this_arg: number): void {
27876 if(!isWasmInitialized) {
27877 throw new Error("initializeWasm() must be awaited first!");
27879 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27880 // debug statements here
27882 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27884 export function NodeFeatures_set_gossip_queries_required(this_arg: number): void {
27885 if(!isWasmInitialized) {
27886 throw new Error("initializeWasm() must be awaited first!");
27888 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27889 // debug statements here
27891 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27893 export function NodeFeatures_supports_gossip_queries(this_arg: number): boolean {
27894 if(!isWasmInitialized) {
27895 throw new Error("initializeWasm() must be awaited first!");
27897 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27898 return nativeResponseValue;
27900 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27902 export function InitFeatures_requires_gossip_queries(this_arg: number): boolean {
27903 if(!isWasmInitialized) {
27904 throw new Error("initializeWasm() must be awaited first!");
27906 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27907 return nativeResponseValue;
27909 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27911 export function NodeFeatures_requires_gossip_queries(this_arg: number): boolean {
27912 if(!isWasmInitialized) {
27913 throw new Error("initializeWasm() must be awaited first!");
27915 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27916 return nativeResponseValue;
27918 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27920 export function InitFeatures_set_variable_length_onion_optional(this_arg: number): void {
27921 if(!isWasmInitialized) {
27922 throw new Error("initializeWasm() must be awaited first!");
27924 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27925 // debug statements here
27927 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27929 export function InitFeatures_set_variable_length_onion_required(this_arg: number): void {
27930 if(!isWasmInitialized) {
27931 throw new Error("initializeWasm() must be awaited first!");
27933 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27934 // debug statements here
27936 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27938 export function InitFeatures_supports_variable_length_onion(this_arg: number): boolean {
27939 if(!isWasmInitialized) {
27940 throw new Error("initializeWasm() must be awaited first!");
27942 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27943 return nativeResponseValue;
27945 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27947 export function NodeFeatures_set_variable_length_onion_optional(this_arg: number): void {
27948 if(!isWasmInitialized) {
27949 throw new Error("initializeWasm() must be awaited first!");
27951 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27952 // debug statements here
27954 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27956 export function NodeFeatures_set_variable_length_onion_required(this_arg: number): void {
27957 if(!isWasmInitialized) {
27958 throw new Error("initializeWasm() must be awaited first!");
27960 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27961 // debug statements here
27963 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27965 export function NodeFeatures_supports_variable_length_onion(this_arg: number): boolean {
27966 if(!isWasmInitialized) {
27967 throw new Error("initializeWasm() must be awaited first!");
27969 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27970 return nativeResponseValue;
27972 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27974 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: number): void {
27975 if(!isWasmInitialized) {
27976 throw new Error("initializeWasm() must be awaited first!");
27978 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27979 // debug statements here
27981 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27983 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: number): void {
27984 if(!isWasmInitialized) {
27985 throw new Error("initializeWasm() must be awaited first!");
27987 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27988 // debug statements here
27990 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27992 export function InvoiceFeatures_supports_variable_length_onion(this_arg: number): boolean {
27993 if(!isWasmInitialized) {
27994 throw new Error("initializeWasm() must be awaited first!");
27996 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
27997 return nativeResponseValue;
27999 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28001 export function InitFeatures_requires_variable_length_onion(this_arg: number): boolean {
28002 if(!isWasmInitialized) {
28003 throw new Error("initializeWasm() must be awaited first!");
28005 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
28006 return nativeResponseValue;
28008 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28010 export function NodeFeatures_requires_variable_length_onion(this_arg: number): boolean {
28011 if(!isWasmInitialized) {
28012 throw new Error("initializeWasm() must be awaited first!");
28014 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
28015 return nativeResponseValue;
28017 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28019 export function InvoiceFeatures_requires_variable_length_onion(this_arg: number): boolean {
28020 if(!isWasmInitialized) {
28021 throw new Error("initializeWasm() must be awaited first!");
28023 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
28024 return nativeResponseValue;
28026 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28028 export function InitFeatures_set_static_remote_key_optional(this_arg: number): void {
28029 if(!isWasmInitialized) {
28030 throw new Error("initializeWasm() must be awaited first!");
28032 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
28033 // debug statements here
28035 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28037 export function InitFeatures_set_static_remote_key_required(this_arg: number): void {
28038 if(!isWasmInitialized) {
28039 throw new Error("initializeWasm() must be awaited first!");
28041 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
28042 // debug statements here
28044 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28046 export function InitFeatures_supports_static_remote_key(this_arg: number): boolean {
28047 if(!isWasmInitialized) {
28048 throw new Error("initializeWasm() must be awaited first!");
28050 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
28051 return nativeResponseValue;
28053 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28055 export function NodeFeatures_set_static_remote_key_optional(this_arg: number): void {
28056 if(!isWasmInitialized) {
28057 throw new Error("initializeWasm() must be awaited first!");
28059 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
28060 // debug statements here
28062 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28064 export function NodeFeatures_set_static_remote_key_required(this_arg: number): void {
28065 if(!isWasmInitialized) {
28066 throw new Error("initializeWasm() must be awaited first!");
28068 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
28069 // debug statements here
28071 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28073 export function NodeFeatures_supports_static_remote_key(this_arg: number): boolean {
28074 if(!isWasmInitialized) {
28075 throw new Error("initializeWasm() must be awaited first!");
28077 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
28078 return nativeResponseValue;
28080 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28082 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: number): void {
28083 if(!isWasmInitialized) {
28084 throw new Error("initializeWasm() must be awaited first!");
28086 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
28087 // debug statements here
28089 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28091 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: number): void {
28092 if(!isWasmInitialized) {
28093 throw new Error("initializeWasm() must be awaited first!");
28095 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
28096 // debug statements here
28098 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28100 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: number): boolean {
28101 if(!isWasmInitialized) {
28102 throw new Error("initializeWasm() must be awaited first!");
28104 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
28105 return nativeResponseValue;
28107 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28109 export function InitFeatures_requires_static_remote_key(this_arg: number): boolean {
28110 if(!isWasmInitialized) {
28111 throw new Error("initializeWasm() must be awaited first!");
28113 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
28114 return nativeResponseValue;
28116 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28118 export function NodeFeatures_requires_static_remote_key(this_arg: number): boolean {
28119 if(!isWasmInitialized) {
28120 throw new Error("initializeWasm() must be awaited first!");
28122 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
28123 return nativeResponseValue;
28125 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28127 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: number): boolean {
28128 if(!isWasmInitialized) {
28129 throw new Error("initializeWasm() must be awaited first!");
28131 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
28132 return nativeResponseValue;
28134 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28136 export function InitFeatures_set_payment_secret_optional(this_arg: number): void {
28137 if(!isWasmInitialized) {
28138 throw new Error("initializeWasm() must be awaited first!");
28140 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
28141 // debug statements here
28143 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28145 export function InitFeatures_set_payment_secret_required(this_arg: number): void {
28146 if(!isWasmInitialized) {
28147 throw new Error("initializeWasm() must be awaited first!");
28149 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
28150 // debug statements here
28152 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28154 export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
28155 if(!isWasmInitialized) {
28156 throw new Error("initializeWasm() must be awaited first!");
28158 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
28159 return nativeResponseValue;
28161 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28163 export function NodeFeatures_set_payment_secret_optional(this_arg: number): void {
28164 if(!isWasmInitialized) {
28165 throw new Error("initializeWasm() must be awaited first!");
28167 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
28168 // debug statements here
28170 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28172 export function NodeFeatures_set_payment_secret_required(this_arg: number): void {
28173 if(!isWasmInitialized) {
28174 throw new Error("initializeWasm() must be awaited first!");
28176 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
28177 // debug statements here
28179 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28181 export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
28182 if(!isWasmInitialized) {
28183 throw new Error("initializeWasm() must be awaited first!");
28185 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
28186 return nativeResponseValue;
28188 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28190 export function InvoiceFeatures_set_payment_secret_optional(this_arg: number): void {
28191 if(!isWasmInitialized) {
28192 throw new Error("initializeWasm() must be awaited first!");
28194 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
28195 // debug statements here
28197 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28199 export function InvoiceFeatures_set_payment_secret_required(this_arg: number): void {
28200 if(!isWasmInitialized) {
28201 throw new Error("initializeWasm() must be awaited first!");
28203 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
28204 // debug statements here
28206 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28208 export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
28209 if(!isWasmInitialized) {
28210 throw new Error("initializeWasm() must be awaited first!");
28212 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
28213 return nativeResponseValue;
28215 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28217 export function InitFeatures_requires_payment_secret(this_arg: number): boolean {
28218 if(!isWasmInitialized) {
28219 throw new Error("initializeWasm() must be awaited first!");
28221 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
28222 return nativeResponseValue;
28224 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28226 export function NodeFeatures_requires_payment_secret(this_arg: number): boolean {
28227 if(!isWasmInitialized) {
28228 throw new Error("initializeWasm() must be awaited first!");
28230 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
28231 return nativeResponseValue;
28233 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28235 export function InvoiceFeatures_requires_payment_secret(this_arg: number): boolean {
28236 if(!isWasmInitialized) {
28237 throw new Error("initializeWasm() must be awaited first!");
28239 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
28240 return nativeResponseValue;
28242 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28244 export function InitFeatures_set_basic_mpp_optional(this_arg: number): void {
28245 if(!isWasmInitialized) {
28246 throw new Error("initializeWasm() must be awaited first!");
28248 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
28249 // debug statements here
28251 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28253 export function InitFeatures_set_basic_mpp_required(this_arg: number): void {
28254 if(!isWasmInitialized) {
28255 throw new Error("initializeWasm() must be awaited first!");
28257 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
28258 // debug statements here
28260 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28262 export function InitFeatures_supports_basic_mpp(this_arg: number): boolean {
28263 if(!isWasmInitialized) {
28264 throw new Error("initializeWasm() must be awaited first!");
28266 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
28267 return nativeResponseValue;
28269 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28271 export function NodeFeatures_set_basic_mpp_optional(this_arg: number): void {
28272 if(!isWasmInitialized) {
28273 throw new Error("initializeWasm() must be awaited first!");
28275 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
28276 // debug statements here
28278 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28280 export function NodeFeatures_set_basic_mpp_required(this_arg: number): void {
28281 if(!isWasmInitialized) {
28282 throw new Error("initializeWasm() must be awaited first!");
28284 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
28285 // debug statements here
28287 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28289 export function NodeFeatures_supports_basic_mpp(this_arg: number): boolean {
28290 if(!isWasmInitialized) {
28291 throw new Error("initializeWasm() must be awaited first!");
28293 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
28294 return nativeResponseValue;
28296 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28298 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: number): void {
28299 if(!isWasmInitialized) {
28300 throw new Error("initializeWasm() must be awaited first!");
28302 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
28303 // debug statements here
28305 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28307 export function InvoiceFeatures_set_basic_mpp_required(this_arg: number): void {
28308 if(!isWasmInitialized) {
28309 throw new Error("initializeWasm() must be awaited first!");
28311 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
28312 // debug statements here
28314 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28316 export function InvoiceFeatures_supports_basic_mpp(this_arg: number): boolean {
28317 if(!isWasmInitialized) {
28318 throw new Error("initializeWasm() must be awaited first!");
28320 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
28321 return nativeResponseValue;
28323 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28325 export function InitFeatures_requires_basic_mpp(this_arg: number): boolean {
28326 if(!isWasmInitialized) {
28327 throw new Error("initializeWasm() must be awaited first!");
28329 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
28330 return nativeResponseValue;
28332 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28334 export function NodeFeatures_requires_basic_mpp(this_arg: number): boolean {
28335 if(!isWasmInitialized) {
28336 throw new Error("initializeWasm() must be awaited first!");
28338 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
28339 return nativeResponseValue;
28341 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28343 export function InvoiceFeatures_requires_basic_mpp(this_arg: number): boolean {
28344 if(!isWasmInitialized) {
28345 throw new Error("initializeWasm() must be awaited first!");
28347 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
28348 return nativeResponseValue;
28350 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28352 export function InitFeatures_set_wumbo_optional(this_arg: number): void {
28353 if(!isWasmInitialized) {
28354 throw new Error("initializeWasm() must be awaited first!");
28356 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
28357 // debug statements here
28359 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28361 export function InitFeatures_set_wumbo_required(this_arg: number): void {
28362 if(!isWasmInitialized) {
28363 throw new Error("initializeWasm() must be awaited first!");
28365 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
28366 // debug statements here
28368 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28370 export function InitFeatures_supports_wumbo(this_arg: number): boolean {
28371 if(!isWasmInitialized) {
28372 throw new Error("initializeWasm() must be awaited first!");
28374 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
28375 return nativeResponseValue;
28377 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28379 export function NodeFeatures_set_wumbo_optional(this_arg: number): void {
28380 if(!isWasmInitialized) {
28381 throw new Error("initializeWasm() must be awaited first!");
28383 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
28384 // debug statements here
28386 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28388 export function NodeFeatures_set_wumbo_required(this_arg: number): void {
28389 if(!isWasmInitialized) {
28390 throw new Error("initializeWasm() must be awaited first!");
28392 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
28393 // debug statements here
28395 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28397 export function NodeFeatures_supports_wumbo(this_arg: number): boolean {
28398 if(!isWasmInitialized) {
28399 throw new Error("initializeWasm() must be awaited first!");
28401 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
28402 return nativeResponseValue;
28404 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28406 export function InitFeatures_requires_wumbo(this_arg: number): boolean {
28407 if(!isWasmInitialized) {
28408 throw new Error("initializeWasm() must be awaited first!");
28410 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
28411 return nativeResponseValue;
28413 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28415 export function NodeFeatures_requires_wumbo(this_arg: number): boolean {
28416 if(!isWasmInitialized) {
28417 throw new Error("initializeWasm() must be awaited first!");
28419 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
28420 return nativeResponseValue;
28422 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28424 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
28425 if(!isWasmInitialized) {
28426 throw new Error("initializeWasm() must be awaited first!");
28428 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
28429 // debug statements here
28431 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28433 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
28434 if(!isWasmInitialized) {
28435 throw new Error("initializeWasm() must be awaited first!");
28437 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
28438 // debug statements here
28440 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28442 export function InitFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
28443 if(!isWasmInitialized) {
28444 throw new Error("initializeWasm() must be awaited first!");
28446 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
28447 return nativeResponseValue;
28449 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28451 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
28452 if(!isWasmInitialized) {
28453 throw new Error("initializeWasm() must be awaited first!");
28455 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
28456 // debug statements here
28458 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28460 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
28461 if(!isWasmInitialized) {
28462 throw new Error("initializeWasm() must be awaited first!");
28464 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
28465 // debug statements here
28467 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28469 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
28470 if(!isWasmInitialized) {
28471 throw new Error("initializeWasm() must be awaited first!");
28473 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
28474 return nativeResponseValue;
28476 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28478 export function InitFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
28479 if(!isWasmInitialized) {
28480 throw new Error("initializeWasm() must be awaited first!");
28482 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
28483 return nativeResponseValue;
28485 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28487 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
28488 if(!isWasmInitialized) {
28489 throw new Error("initializeWasm() must be awaited first!");
28491 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
28492 return nativeResponseValue;
28494 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28496 export function InitFeatures_set_channel_type_optional(this_arg: number): void {
28497 if(!isWasmInitialized) {
28498 throw new Error("initializeWasm() must be awaited first!");
28500 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
28501 // debug statements here
28503 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28505 export function InitFeatures_set_channel_type_required(this_arg: number): void {
28506 if(!isWasmInitialized) {
28507 throw new Error("initializeWasm() must be awaited first!");
28509 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
28510 // debug statements here
28512 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28514 export function InitFeatures_supports_channel_type(this_arg: number): boolean {
28515 if(!isWasmInitialized) {
28516 throw new Error("initializeWasm() must be awaited first!");
28518 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
28519 return nativeResponseValue;
28521 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28523 export function NodeFeatures_set_channel_type_optional(this_arg: number): void {
28524 if(!isWasmInitialized) {
28525 throw new Error("initializeWasm() must be awaited first!");
28527 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
28528 // debug statements here
28530 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28532 export function NodeFeatures_set_channel_type_required(this_arg: number): void {
28533 if(!isWasmInitialized) {
28534 throw new Error("initializeWasm() must be awaited first!");
28536 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
28537 // debug statements here
28539 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28541 export function NodeFeatures_supports_channel_type(this_arg: number): boolean {
28542 if(!isWasmInitialized) {
28543 throw new Error("initializeWasm() must be awaited first!");
28545 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
28546 return nativeResponseValue;
28548 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28550 export function InitFeatures_requires_channel_type(this_arg: number): boolean {
28551 if(!isWasmInitialized) {
28552 throw new Error("initializeWasm() must be awaited first!");
28554 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
28555 return nativeResponseValue;
28557 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28559 export function NodeFeatures_requires_channel_type(this_arg: number): boolean {
28560 if(!isWasmInitialized) {
28561 throw new Error("initializeWasm() must be awaited first!");
28563 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
28564 return nativeResponseValue;
28566 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28568 export function InitFeatures_set_scid_privacy_optional(this_arg: number): void {
28569 if(!isWasmInitialized) {
28570 throw new Error("initializeWasm() must be awaited first!");
28572 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
28573 // debug statements here
28575 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28577 export function InitFeatures_set_scid_privacy_required(this_arg: number): void {
28578 if(!isWasmInitialized) {
28579 throw new Error("initializeWasm() must be awaited first!");
28581 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
28582 // debug statements here
28584 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28586 export function InitFeatures_supports_scid_privacy(this_arg: number): boolean {
28587 if(!isWasmInitialized) {
28588 throw new Error("initializeWasm() must be awaited first!");
28590 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
28591 return nativeResponseValue;
28593 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28595 export function NodeFeatures_set_scid_privacy_optional(this_arg: number): void {
28596 if(!isWasmInitialized) {
28597 throw new Error("initializeWasm() must be awaited first!");
28599 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
28600 // debug statements here
28602 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28604 export function NodeFeatures_set_scid_privacy_required(this_arg: number): void {
28605 if(!isWasmInitialized) {
28606 throw new Error("initializeWasm() must be awaited first!");
28608 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
28609 // debug statements here
28611 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28613 export function NodeFeatures_supports_scid_privacy(this_arg: number): boolean {
28614 if(!isWasmInitialized) {
28615 throw new Error("initializeWasm() must be awaited first!");
28617 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
28618 return nativeResponseValue;
28620 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28622 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: number): void {
28623 if(!isWasmInitialized) {
28624 throw new Error("initializeWasm() must be awaited first!");
28626 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
28627 // debug statements here
28629 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28631 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: number): void {
28632 if(!isWasmInitialized) {
28633 throw new Error("initializeWasm() must be awaited first!");
28635 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
28636 // debug statements here
28638 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28640 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: number): boolean {
28641 if(!isWasmInitialized) {
28642 throw new Error("initializeWasm() must be awaited first!");
28644 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
28645 return nativeResponseValue;
28647 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28649 export function InitFeatures_requires_scid_privacy(this_arg: number): boolean {
28650 if(!isWasmInitialized) {
28651 throw new Error("initializeWasm() must be awaited first!");
28653 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
28654 return nativeResponseValue;
28656 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28658 export function NodeFeatures_requires_scid_privacy(this_arg: number): boolean {
28659 if(!isWasmInitialized) {
28660 throw new Error("initializeWasm() must be awaited first!");
28662 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
28663 return nativeResponseValue;
28665 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28667 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: number): boolean {
28668 if(!isWasmInitialized) {
28669 throw new Error("initializeWasm() must be awaited first!");
28671 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
28672 return nativeResponseValue;
28674 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28676 export function InitFeatures_set_zero_conf_optional(this_arg: number): void {
28677 if(!isWasmInitialized) {
28678 throw new Error("initializeWasm() must be awaited first!");
28680 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
28681 // debug statements here
28683 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28685 export function InitFeatures_set_zero_conf_required(this_arg: number): void {
28686 if(!isWasmInitialized) {
28687 throw new Error("initializeWasm() must be awaited first!");
28689 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
28690 // debug statements here
28692 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28694 export function InitFeatures_supports_zero_conf(this_arg: number): boolean {
28695 if(!isWasmInitialized) {
28696 throw new Error("initializeWasm() must be awaited first!");
28698 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
28699 return nativeResponseValue;
28701 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28703 export function NodeFeatures_set_zero_conf_optional(this_arg: number): void {
28704 if(!isWasmInitialized) {
28705 throw new Error("initializeWasm() must be awaited first!");
28707 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
28708 // debug statements here
28710 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28712 export function NodeFeatures_set_zero_conf_required(this_arg: number): void {
28713 if(!isWasmInitialized) {
28714 throw new Error("initializeWasm() must be awaited first!");
28716 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
28717 // debug statements here
28719 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28721 export function NodeFeatures_supports_zero_conf(this_arg: number): boolean {
28722 if(!isWasmInitialized) {
28723 throw new Error("initializeWasm() must be awaited first!");
28725 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
28726 return nativeResponseValue;
28728 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28730 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: number): void {
28731 if(!isWasmInitialized) {
28732 throw new Error("initializeWasm() must be awaited first!");
28734 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
28735 // debug statements here
28737 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28739 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: number): void {
28740 if(!isWasmInitialized) {
28741 throw new Error("initializeWasm() must be awaited first!");
28743 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
28744 // debug statements here
28746 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28748 export function ChannelTypeFeatures_supports_zero_conf(this_arg: number): boolean {
28749 if(!isWasmInitialized) {
28750 throw new Error("initializeWasm() must be awaited first!");
28752 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
28753 return nativeResponseValue;
28755 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28757 export function InitFeatures_requires_zero_conf(this_arg: number): boolean {
28758 if(!isWasmInitialized) {
28759 throw new Error("initializeWasm() must be awaited first!");
28761 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
28762 return nativeResponseValue;
28764 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28766 export function NodeFeatures_requires_zero_conf(this_arg: number): boolean {
28767 if(!isWasmInitialized) {
28768 throw new Error("initializeWasm() must be awaited first!");
28770 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
28771 return nativeResponseValue;
28773 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28775 export function ChannelTypeFeatures_requires_zero_conf(this_arg: number): boolean {
28776 if(!isWasmInitialized) {
28777 throw new Error("initializeWasm() must be awaited first!");
28779 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
28780 return nativeResponseValue;
28782 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28784 export function NodeFeatures_set_keysend_optional(this_arg: number): void {
28785 if(!isWasmInitialized) {
28786 throw new Error("initializeWasm() must be awaited first!");
28788 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
28789 // debug statements here
28791 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28793 export function NodeFeatures_set_keysend_required(this_arg: number): void {
28794 if(!isWasmInitialized) {
28795 throw new Error("initializeWasm() must be awaited first!");
28797 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
28798 // debug statements here
28800 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28802 export function NodeFeatures_supports_keysend(this_arg: number): boolean {
28803 if(!isWasmInitialized) {
28804 throw new Error("initializeWasm() must be awaited first!");
28806 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
28807 return nativeResponseValue;
28809 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28811 export function NodeFeatures_requires_keysend(this_arg: number): boolean {
28812 if(!isWasmInitialized) {
28813 throw new Error("initializeWasm() must be awaited first!");
28815 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
28816 return nativeResponseValue;
28818 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
28820 export function ShutdownScript_free(this_obj: number): void {
28821 if(!isWasmInitialized) {
28822 throw new Error("initializeWasm() must be awaited first!");
28824 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
28825 // debug statements here
28827 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
28829 export function ShutdownScript_clone_ptr(arg: number): number {
28830 if(!isWasmInitialized) {
28831 throw new Error("initializeWasm() must be awaited first!");
28833 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
28834 return nativeResponseValue;
28836 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
28838 export function ShutdownScript_clone(orig: number): number {
28839 if(!isWasmInitialized) {
28840 throw new Error("initializeWasm() must be awaited first!");
28842 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
28843 return nativeResponseValue;
28845 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
28847 export function InvalidShutdownScript_free(this_obj: number): void {
28848 if(!isWasmInitialized) {
28849 throw new Error("initializeWasm() must be awaited first!");
28851 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
28852 // debug statements here
28854 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
28856 export function InvalidShutdownScript_get_script(this_ptr: number): number {
28857 if(!isWasmInitialized) {
28858 throw new Error("initializeWasm() must be awaited first!");
28860 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
28861 return nativeResponseValue;
28863 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
28865 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
28866 if(!isWasmInitialized) {
28867 throw new Error("initializeWasm() must be awaited first!");
28869 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
28870 // debug statements here
28872 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28874 export function InvalidShutdownScript_new(script_arg: number): number {
28875 if(!isWasmInitialized) {
28876 throw new Error("initializeWasm() must be awaited first!");
28878 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28879 return nativeResponseValue;
28881 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28883 export function InvalidShutdownScript_clone_ptr(arg: number): number {
28884 if(!isWasmInitialized) {
28885 throw new Error("initializeWasm() must be awaited first!");
28887 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28888 return nativeResponseValue;
28890 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28892 export function InvalidShutdownScript_clone(orig: number): number {
28893 if(!isWasmInitialized) {
28894 throw new Error("initializeWasm() must be awaited first!");
28896 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28897 return nativeResponseValue;
28899 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28901 export function ShutdownScript_write(obj: number): number {
28902 if(!isWasmInitialized) {
28903 throw new Error("initializeWasm() must be awaited first!");
28905 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28906 return nativeResponseValue;
28908 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28910 export function ShutdownScript_read(ser: number): number {
28911 if(!isWasmInitialized) {
28912 throw new Error("initializeWasm() must be awaited first!");
28914 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28915 return nativeResponseValue;
28917 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28919 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
28920 if(!isWasmInitialized) {
28921 throw new Error("initializeWasm() must be awaited first!");
28923 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28924 return nativeResponseValue;
28926 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28928 export function ShutdownScript_new_p2wsh(script_hash: number): number {
28929 if(!isWasmInitialized) {
28930 throw new Error("initializeWasm() must be awaited first!");
28932 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28933 return nativeResponseValue;
28935 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28937 export function ShutdownScript_new_witness_program(version: number, program: number): number {
28938 if(!isWasmInitialized) {
28939 throw new Error("initializeWasm() must be awaited first!");
28941 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28942 return nativeResponseValue;
28944 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28946 export function ShutdownScript_into_inner(this_arg: number): number {
28947 if(!isWasmInitialized) {
28948 throw new Error("initializeWasm() must be awaited first!");
28950 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28951 return nativeResponseValue;
28953 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28955 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
28956 if(!isWasmInitialized) {
28957 throw new Error("initializeWasm() must be awaited first!");
28959 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28960 return nativeResponseValue;
28962 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28964 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
28965 if(!isWasmInitialized) {
28966 throw new Error("initializeWasm() must be awaited first!");
28968 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28969 return nativeResponseValue;
28971 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28973 export function CustomMessageReader_free(this_ptr: number): void {
28974 if(!isWasmInitialized) {
28975 throw new Error("initializeWasm() must be awaited first!");
28977 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28978 // debug statements here
28980 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28982 export function Type_clone_ptr(arg: number): number {
28983 if(!isWasmInitialized) {
28984 throw new Error("initializeWasm() must be awaited first!");
28986 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28987 return nativeResponseValue;
28989 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28991 export function Type_clone(orig: number): number {
28992 if(!isWasmInitialized) {
28993 throw new Error("initializeWasm() must be awaited first!");
28995 const nativeResponseValue = wasm.TS_Type_clone(orig);
28996 return nativeResponseValue;
28998 // void Type_free(struct LDKType this_ptr);
29000 export function Type_free(this_ptr: number): void {
29001 if(!isWasmInitialized) {
29002 throw new Error("initializeWasm() must be awaited first!");
29004 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
29005 // debug statements here
29007 // void NodeId_free(struct LDKNodeId this_obj);
29009 export function NodeId_free(this_obj: number): void {
29010 if(!isWasmInitialized) {
29011 throw new Error("initializeWasm() must be awaited first!");
29013 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
29014 // debug statements here
29016 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
29018 export function NodeId_clone_ptr(arg: number): number {
29019 if(!isWasmInitialized) {
29020 throw new Error("initializeWasm() must be awaited first!");
29022 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
29023 return nativeResponseValue;
29025 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
29027 export function NodeId_clone(orig: number): number {
29028 if(!isWasmInitialized) {
29029 throw new Error("initializeWasm() must be awaited first!");
29031 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
29032 return nativeResponseValue;
29034 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
29036 export function NodeId_from_pubkey(pubkey: number): number {
29037 if(!isWasmInitialized) {
29038 throw new Error("initializeWasm() must be awaited first!");
29040 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
29041 return nativeResponseValue;
29043 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
29045 export function NodeId_as_slice(this_arg: number): number {
29046 if(!isWasmInitialized) {
29047 throw new Error("initializeWasm() must be awaited first!");
29049 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
29050 return nativeResponseValue;
29052 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
29054 export function NodeId_hash(o: number): bigint {
29055 if(!isWasmInitialized) {
29056 throw new Error("initializeWasm() must be awaited first!");
29058 const nativeResponseValue = wasm.TS_NodeId_hash(o);
29059 return nativeResponseValue;
29061 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
29063 export function NodeId_write(obj: number): number {
29064 if(!isWasmInitialized) {
29065 throw new Error("initializeWasm() must be awaited first!");
29067 const nativeResponseValue = wasm.TS_NodeId_write(obj);
29068 return nativeResponseValue;
29070 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
29072 export function NodeId_read(ser: number): number {
29073 if(!isWasmInitialized) {
29074 throw new Error("initializeWasm() must be awaited first!");
29076 const nativeResponseValue = wasm.TS_NodeId_read(ser);
29077 return nativeResponseValue;
29079 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
29081 export function NetworkGraph_free(this_obj: number): void {
29082 if(!isWasmInitialized) {
29083 throw new Error("initializeWasm() must be awaited first!");
29085 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
29086 // debug statements here
29088 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
29090 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
29091 if(!isWasmInitialized) {
29092 throw new Error("initializeWasm() must be awaited first!");
29094 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
29095 // debug statements here
29097 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
29099 export function NetworkUpdate_free(this_ptr: number): void {
29100 if(!isWasmInitialized) {
29101 throw new Error("initializeWasm() must be awaited first!");
29103 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
29104 // debug statements here
29106 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
29108 export function NetworkUpdate_clone_ptr(arg: number): number {
29109 if(!isWasmInitialized) {
29110 throw new Error("initializeWasm() must be awaited first!");
29112 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
29113 return nativeResponseValue;
29115 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
29117 export function NetworkUpdate_clone(orig: number): number {
29118 if(!isWasmInitialized) {
29119 throw new Error("initializeWasm() must be awaited first!");
29121 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
29122 return nativeResponseValue;
29124 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
29126 export function NetworkUpdate_channel_update_message(msg: number): number {
29127 if(!isWasmInitialized) {
29128 throw new Error("initializeWasm() must be awaited first!");
29130 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
29131 return nativeResponseValue;
29133 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
29135 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): number {
29136 if(!isWasmInitialized) {
29137 throw new Error("initializeWasm() must be awaited first!");
29139 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
29140 return nativeResponseValue;
29142 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
29144 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
29145 if(!isWasmInitialized) {
29146 throw new Error("initializeWasm() must be awaited first!");
29148 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
29149 return nativeResponseValue;
29151 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
29153 export function NetworkUpdate_write(obj: number): number {
29154 if(!isWasmInitialized) {
29155 throw new Error("initializeWasm() must be awaited first!");
29157 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
29158 return nativeResponseValue;
29160 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
29162 export function NetworkUpdate_read(ser: number): number {
29163 if(!isWasmInitialized) {
29164 throw new Error("initializeWasm() must be awaited first!");
29166 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
29167 return nativeResponseValue;
29169 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
29171 export function P2PGossipSync_free(this_obj: number): void {
29172 if(!isWasmInitialized) {
29173 throw new Error("initializeWasm() must be awaited first!");
29175 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
29176 // debug statements here
29178 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
29180 export function P2PGossipSync_new(network_graph: number, chain_access: number, logger: number): number {
29181 if(!isWasmInitialized) {
29182 throw new Error("initializeWasm() must be awaited first!");
29184 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
29185 return nativeResponseValue;
29187 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
29189 export function P2PGossipSync_add_chain_access(this_arg: number, chain_access: number): void {
29190 if(!isWasmInitialized) {
29191 throw new Error("initializeWasm() must be awaited first!");
29193 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
29194 // debug statements here
29196 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29198 export function NetworkGraph_as_EventHandler(this_arg: number): number {
29199 if(!isWasmInitialized) {
29200 throw new Error("initializeWasm() must be awaited first!");
29202 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
29203 return nativeResponseValue;
29205 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
29207 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: number): number {
29208 if(!isWasmInitialized) {
29209 throw new Error("initializeWasm() must be awaited first!");
29211 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
29212 return nativeResponseValue;
29214 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
29216 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: number): number {
29217 if(!isWasmInitialized) {
29218 throw new Error("initializeWasm() must be awaited first!");
29220 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
29221 return nativeResponseValue;
29223 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
29225 export function ChannelUpdateInfo_free(this_obj: number): void {
29226 if(!isWasmInitialized) {
29227 throw new Error("initializeWasm() must be awaited first!");
29229 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
29230 // debug statements here
29232 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29234 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
29235 if(!isWasmInitialized) {
29236 throw new Error("initializeWasm() must be awaited first!");
29238 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
29239 return nativeResponseValue;
29241 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
29243 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
29244 if(!isWasmInitialized) {
29245 throw new Error("initializeWasm() must be awaited first!");
29247 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
29248 // debug statements here
29250 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29252 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
29253 if(!isWasmInitialized) {
29254 throw new Error("initializeWasm() must be awaited first!");
29256 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
29257 return nativeResponseValue;
29259 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
29261 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
29262 if(!isWasmInitialized) {
29263 throw new Error("initializeWasm() must be awaited first!");
29265 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
29266 // debug statements here
29268 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29270 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
29271 if(!isWasmInitialized) {
29272 throw new Error("initializeWasm() must be awaited first!");
29274 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
29275 return nativeResponseValue;
29277 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
29279 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
29280 if(!isWasmInitialized) {
29281 throw new Error("initializeWasm() must be awaited first!");
29283 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
29284 // debug statements here
29286 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29288 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
29289 if(!isWasmInitialized) {
29290 throw new Error("initializeWasm() must be awaited first!");
29292 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
29293 return nativeResponseValue;
29295 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
29297 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
29298 if(!isWasmInitialized) {
29299 throw new Error("initializeWasm() must be awaited first!");
29301 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
29302 // debug statements here
29304 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29306 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): bigint {
29307 if(!isWasmInitialized) {
29308 throw new Error("initializeWasm() must be awaited first!");
29310 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
29311 return nativeResponseValue;
29313 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
29315 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: bigint): void {
29316 if(!isWasmInitialized) {
29317 throw new Error("initializeWasm() must be awaited first!");
29319 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
29320 // debug statements here
29322 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29324 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
29325 if(!isWasmInitialized) {
29326 throw new Error("initializeWasm() must be awaited first!");
29328 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
29329 return nativeResponseValue;
29331 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29333 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
29334 if(!isWasmInitialized) {
29335 throw new Error("initializeWasm() must be awaited first!");
29337 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
29338 // debug statements here
29340 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29342 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
29343 if(!isWasmInitialized) {
29344 throw new Error("initializeWasm() must be awaited first!");
29346 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
29347 return nativeResponseValue;
29349 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
29351 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
29352 if(!isWasmInitialized) {
29353 throw new Error("initializeWasm() must be awaited first!");
29355 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
29356 // debug statements here
29358 // 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);
29360 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: number, last_update_message_arg: number): number {
29361 if(!isWasmInitialized) {
29362 throw new Error("initializeWasm() must be awaited first!");
29364 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);
29365 return nativeResponseValue;
29367 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
29369 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
29370 if(!isWasmInitialized) {
29371 throw new Error("initializeWasm() must be awaited first!");
29373 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
29374 return nativeResponseValue;
29376 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
29378 export function ChannelUpdateInfo_clone(orig: number): number {
29379 if(!isWasmInitialized) {
29380 throw new Error("initializeWasm() must be awaited first!");
29382 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
29383 return nativeResponseValue;
29385 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
29387 export function ChannelUpdateInfo_write(obj: number): number {
29388 if(!isWasmInitialized) {
29389 throw new Error("initializeWasm() must be awaited first!");
29391 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
29392 return nativeResponseValue;
29394 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
29396 export function ChannelUpdateInfo_read(ser: number): number {
29397 if(!isWasmInitialized) {
29398 throw new Error("initializeWasm() must be awaited first!");
29400 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
29401 return nativeResponseValue;
29403 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
29405 export function ChannelInfo_free(this_obj: number): void {
29406 if(!isWasmInitialized) {
29407 throw new Error("initializeWasm() must be awaited first!");
29409 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
29410 // debug statements here
29412 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29414 export function ChannelInfo_get_features(this_ptr: number): number {
29415 if(!isWasmInitialized) {
29416 throw new Error("initializeWasm() must be awaited first!");
29418 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
29419 return nativeResponseValue;
29421 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29423 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
29424 if(!isWasmInitialized) {
29425 throw new Error("initializeWasm() must be awaited first!");
29427 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
29428 // debug statements here
29430 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29432 export function ChannelInfo_get_node_one(this_ptr: number): number {
29433 if(!isWasmInitialized) {
29434 throw new Error("initializeWasm() must be awaited first!");
29436 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
29437 return nativeResponseValue;
29439 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
29441 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
29442 if(!isWasmInitialized) {
29443 throw new Error("initializeWasm() must be awaited first!");
29445 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
29446 // debug statements here
29448 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29450 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
29451 if(!isWasmInitialized) {
29452 throw new Error("initializeWasm() must be awaited first!");
29454 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
29455 return nativeResponseValue;
29457 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
29459 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
29460 if(!isWasmInitialized) {
29461 throw new Error("initializeWasm() must be awaited first!");
29463 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
29464 // debug statements here
29466 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29468 export function ChannelInfo_get_node_two(this_ptr: number): number {
29469 if(!isWasmInitialized) {
29470 throw new Error("initializeWasm() must be awaited first!");
29472 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
29473 return nativeResponseValue;
29475 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
29477 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
29478 if(!isWasmInitialized) {
29479 throw new Error("initializeWasm() must be awaited first!");
29481 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
29482 // debug statements here
29484 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29486 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
29487 if(!isWasmInitialized) {
29488 throw new Error("initializeWasm() must be awaited first!");
29490 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
29491 return nativeResponseValue;
29493 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
29495 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
29496 if(!isWasmInitialized) {
29497 throw new Error("initializeWasm() must be awaited first!");
29499 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
29500 // debug statements here
29502 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29504 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
29505 if(!isWasmInitialized) {
29506 throw new Error("initializeWasm() must be awaited first!");
29508 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
29509 return nativeResponseValue;
29511 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29513 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
29514 if(!isWasmInitialized) {
29515 throw new Error("initializeWasm() must be awaited first!");
29517 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
29518 // debug statements here
29520 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29522 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
29523 if(!isWasmInitialized) {
29524 throw new Error("initializeWasm() must be awaited first!");
29526 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
29527 return nativeResponseValue;
29529 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
29531 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
29532 if(!isWasmInitialized) {
29533 throw new Error("initializeWasm() must be awaited first!");
29535 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
29536 // debug statements here
29538 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
29540 export function ChannelInfo_clone_ptr(arg: number): number {
29541 if(!isWasmInitialized) {
29542 throw new Error("initializeWasm() must be awaited first!");
29544 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
29545 return nativeResponseValue;
29547 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
29549 export function ChannelInfo_clone(orig: number): number {
29550 if(!isWasmInitialized) {
29551 throw new Error("initializeWasm() must be awaited first!");
29553 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
29554 return nativeResponseValue;
29556 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
29558 export function ChannelInfo_get_directional_info(this_arg: number, channel_flags: number): number {
29559 if(!isWasmInitialized) {
29560 throw new Error("initializeWasm() must be awaited first!");
29562 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
29563 return nativeResponseValue;
29565 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
29567 export function ChannelInfo_write(obj: number): number {
29568 if(!isWasmInitialized) {
29569 throw new Error("initializeWasm() must be awaited first!");
29571 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
29572 return nativeResponseValue;
29574 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
29576 export function ChannelInfo_read(ser: number): number {
29577 if(!isWasmInitialized) {
29578 throw new Error("initializeWasm() must be awaited first!");
29580 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
29581 return nativeResponseValue;
29583 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
29585 export function DirectedChannelInfo_free(this_obj: number): void {
29586 if(!isWasmInitialized) {
29587 throw new Error("initializeWasm() must be awaited first!");
29589 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
29590 // debug statements here
29592 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
29594 export function DirectedChannelInfo_clone_ptr(arg: number): number {
29595 if(!isWasmInitialized) {
29596 throw new Error("initializeWasm() must be awaited first!");
29598 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
29599 return nativeResponseValue;
29601 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
29603 export function DirectedChannelInfo_clone(orig: number): number {
29604 if(!isWasmInitialized) {
29605 throw new Error("initializeWasm() must be awaited first!");
29607 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
29608 return nativeResponseValue;
29610 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29612 export function DirectedChannelInfo_channel(this_arg: number): number {
29613 if(!isWasmInitialized) {
29614 throw new Error("initializeWasm() must be awaited first!");
29616 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
29617 return nativeResponseValue;
29619 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29621 export function DirectedChannelInfo_direction(this_arg: number): number {
29622 if(!isWasmInitialized) {
29623 throw new Error("initializeWasm() must be awaited first!");
29625 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
29626 return nativeResponseValue;
29628 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29630 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: number): bigint {
29631 if(!isWasmInitialized) {
29632 throw new Error("initializeWasm() must be awaited first!");
29634 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
29635 return nativeResponseValue;
29637 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29639 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
29640 if(!isWasmInitialized) {
29641 throw new Error("initializeWasm() must be awaited first!");
29643 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
29644 return nativeResponseValue;
29646 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
29648 export function EffectiveCapacity_free(this_ptr: number): void {
29649 if(!isWasmInitialized) {
29650 throw new Error("initializeWasm() must be awaited first!");
29652 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
29653 // debug statements here
29655 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
29657 export function EffectiveCapacity_clone_ptr(arg: number): number {
29658 if(!isWasmInitialized) {
29659 throw new Error("initializeWasm() must be awaited first!");
29661 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
29662 return nativeResponseValue;
29664 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
29666 export function EffectiveCapacity_clone(orig: number): number {
29667 if(!isWasmInitialized) {
29668 throw new Error("initializeWasm() must be awaited first!");
29670 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
29671 return nativeResponseValue;
29673 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
29675 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
29676 if(!isWasmInitialized) {
29677 throw new Error("initializeWasm() must be awaited first!");
29679 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
29680 return nativeResponseValue;
29682 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
29684 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
29685 if(!isWasmInitialized) {
29686 throw new Error("initializeWasm() must be awaited first!");
29688 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
29689 return nativeResponseValue;
29691 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
29693 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: number): number {
29694 if(!isWasmInitialized) {
29695 throw new Error("initializeWasm() must be awaited first!");
29697 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
29698 return nativeResponseValue;
29700 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
29702 export function EffectiveCapacity_infinite(): number {
29703 if(!isWasmInitialized) {
29704 throw new Error("initializeWasm() must be awaited first!");
29706 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
29707 return nativeResponseValue;
29709 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
29711 export function EffectiveCapacity_unknown(): number {
29712 if(!isWasmInitialized) {
29713 throw new Error("initializeWasm() must be awaited first!");
29715 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
29716 return nativeResponseValue;
29718 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
29720 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
29721 if(!isWasmInitialized) {
29722 throw new Error("initializeWasm() must be awaited first!");
29724 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
29725 return nativeResponseValue;
29727 // void RoutingFees_free(struct LDKRoutingFees this_obj);
29729 export function RoutingFees_free(this_obj: number): void {
29730 if(!isWasmInitialized) {
29731 throw new Error("initializeWasm() must be awaited first!");
29733 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
29734 // debug statements here
29736 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29738 export function RoutingFees_get_base_msat(this_ptr: number): number {
29739 if(!isWasmInitialized) {
29740 throw new Error("initializeWasm() must be awaited first!");
29742 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
29743 return nativeResponseValue;
29745 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29747 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
29748 if(!isWasmInitialized) {
29749 throw new Error("initializeWasm() must be awaited first!");
29751 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
29752 // debug statements here
29754 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29756 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
29757 if(!isWasmInitialized) {
29758 throw new Error("initializeWasm() must be awaited first!");
29760 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
29761 return nativeResponseValue;
29763 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29765 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
29766 if(!isWasmInitialized) {
29767 throw new Error("initializeWasm() must be awaited first!");
29769 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
29770 // debug statements here
29772 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
29774 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
29775 if(!isWasmInitialized) {
29776 throw new Error("initializeWasm() must be awaited first!");
29778 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
29779 return nativeResponseValue;
29781 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
29783 export function RoutingFees_eq(a: number, b: number): boolean {
29784 if(!isWasmInitialized) {
29785 throw new Error("initializeWasm() must be awaited first!");
29787 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
29788 return nativeResponseValue;
29790 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
29792 export function RoutingFees_clone_ptr(arg: number): number {
29793 if(!isWasmInitialized) {
29794 throw new Error("initializeWasm() must be awaited first!");
29796 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
29797 return nativeResponseValue;
29799 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
29801 export function RoutingFees_clone(orig: number): number {
29802 if(!isWasmInitialized) {
29803 throw new Error("initializeWasm() must be awaited first!");
29805 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
29806 return nativeResponseValue;
29808 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
29810 export function RoutingFees_hash(o: number): bigint {
29811 if(!isWasmInitialized) {
29812 throw new Error("initializeWasm() must be awaited first!");
29814 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
29815 return nativeResponseValue;
29817 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
29819 export function RoutingFees_write(obj: number): number {
29820 if(!isWasmInitialized) {
29821 throw new Error("initializeWasm() must be awaited first!");
29823 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
29824 return nativeResponseValue;
29826 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
29828 export function RoutingFees_read(ser: number): number {
29829 if(!isWasmInitialized) {
29830 throw new Error("initializeWasm() must be awaited first!");
29832 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
29833 return nativeResponseValue;
29835 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
29837 export function NodeAnnouncementInfo_free(this_obj: number): void {
29838 if(!isWasmInitialized) {
29839 throw new Error("initializeWasm() must be awaited first!");
29841 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
29842 // debug statements here
29844 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29846 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
29847 if(!isWasmInitialized) {
29848 throw new Error("initializeWasm() must be awaited first!");
29850 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
29851 return nativeResponseValue;
29853 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29855 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
29856 if(!isWasmInitialized) {
29857 throw new Error("initializeWasm() must be awaited first!");
29859 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
29860 // debug statements here
29862 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29864 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
29865 if(!isWasmInitialized) {
29866 throw new Error("initializeWasm() must be awaited first!");
29868 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
29869 return nativeResponseValue;
29871 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29873 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
29874 if(!isWasmInitialized) {
29875 throw new Error("initializeWasm() must be awaited first!");
29877 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29878 // debug statements here
29880 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29882 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
29883 if(!isWasmInitialized) {
29884 throw new Error("initializeWasm() must be awaited first!");
29886 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29887 return nativeResponseValue;
29889 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29891 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
29892 if(!isWasmInitialized) {
29893 throw new Error("initializeWasm() must be awaited first!");
29895 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29896 // debug statements here
29898 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29900 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
29901 if(!isWasmInitialized) {
29902 throw new Error("initializeWasm() must be awaited first!");
29904 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29905 return nativeResponseValue;
29907 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
29909 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
29910 if(!isWasmInitialized) {
29911 throw new Error("initializeWasm() must be awaited first!");
29913 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29914 // debug statements here
29916 // struct LDKCVec_NetAddressZ NodeAnnouncementInfo_get_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29918 export function NodeAnnouncementInfo_get_addresses(this_ptr: number): number {
29919 if(!isWasmInitialized) {
29920 throw new Error("initializeWasm() must be awaited first!");
29922 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_addresses(this_ptr);
29923 return nativeResponseValue;
29925 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29927 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
29928 if(!isWasmInitialized) {
29929 throw new Error("initializeWasm() must be awaited first!");
29931 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29932 // debug statements here
29934 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29936 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
29937 if(!isWasmInitialized) {
29938 throw new Error("initializeWasm() must be awaited first!");
29940 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29941 return nativeResponseValue;
29943 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29945 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
29946 if(!isWasmInitialized) {
29947 throw new Error("initializeWasm() must be awaited first!");
29949 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29950 // debug statements here
29952 // 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);
29954 export function NodeAnnouncementInfo_new(features_arg: number, last_update_arg: number, rgb_arg: number, alias_arg: number, addresses_arg: number, announcement_message_arg: number): number {
29955 if(!isWasmInitialized) {
29956 throw new Error("initializeWasm() must be awaited first!");
29958 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29959 return nativeResponseValue;
29961 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29963 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
29964 if(!isWasmInitialized) {
29965 throw new Error("initializeWasm() must be awaited first!");
29967 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29968 return nativeResponseValue;
29970 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29972 export function NodeAnnouncementInfo_clone(orig: number): number {
29973 if(!isWasmInitialized) {
29974 throw new Error("initializeWasm() must be awaited first!");
29976 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29977 return nativeResponseValue;
29979 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29981 export function NodeAnnouncementInfo_write(obj: number): number {
29982 if(!isWasmInitialized) {
29983 throw new Error("initializeWasm() must be awaited first!");
29985 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29986 return nativeResponseValue;
29988 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29990 export function NodeAnnouncementInfo_read(ser: number): number {
29991 if(!isWasmInitialized) {
29992 throw new Error("initializeWasm() must be awaited first!");
29994 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
29995 return nativeResponseValue;
29997 // void NodeAlias_free(struct LDKNodeAlias this_obj);
29999 export function NodeAlias_free(this_obj: number): void {
30000 if(!isWasmInitialized) {
30001 throw new Error("initializeWasm() must be awaited first!");
30003 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
30004 // debug statements here
30006 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
30008 export function NodeAlias_get_a(this_ptr: number): number {
30009 if(!isWasmInitialized) {
30010 throw new Error("initializeWasm() must be awaited first!");
30012 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
30013 return nativeResponseValue;
30015 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30017 export function NodeAlias_set_a(this_ptr: number, val: number): void {
30018 if(!isWasmInitialized) {
30019 throw new Error("initializeWasm() must be awaited first!");
30021 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
30022 // debug statements here
30024 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
30026 export function NodeAlias_new(a_arg: number): number {
30027 if(!isWasmInitialized) {
30028 throw new Error("initializeWasm() must be awaited first!");
30030 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
30031 return nativeResponseValue;
30033 // uintptr_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
30035 export function NodeAlias_clone_ptr(arg: number): number {
30036 if(!isWasmInitialized) {
30037 throw new Error("initializeWasm() must be awaited first!");
30039 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
30040 return nativeResponseValue;
30042 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
30044 export function NodeAlias_clone(orig: number): number {
30045 if(!isWasmInitialized) {
30046 throw new Error("initializeWasm() must be awaited first!");
30048 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
30049 return nativeResponseValue;
30051 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
30053 export function NodeAlias_write(obj: number): number {
30054 if(!isWasmInitialized) {
30055 throw new Error("initializeWasm() must be awaited first!");
30057 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
30058 return nativeResponseValue;
30060 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
30062 export function NodeAlias_read(ser: number): number {
30063 if(!isWasmInitialized) {
30064 throw new Error("initializeWasm() must be awaited first!");
30066 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
30067 return nativeResponseValue;
30069 // void NodeInfo_free(struct LDKNodeInfo this_obj);
30071 export function NodeInfo_free(this_obj: number): void {
30072 if(!isWasmInitialized) {
30073 throw new Error("initializeWasm() must be awaited first!");
30075 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
30076 // debug statements here
30078 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30080 export function NodeInfo_get_channels(this_ptr: number): number {
30081 if(!isWasmInitialized) {
30082 throw new Error("initializeWasm() must be awaited first!");
30084 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
30085 return nativeResponseValue;
30087 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
30089 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
30090 if(!isWasmInitialized) {
30091 throw new Error("initializeWasm() must be awaited first!");
30093 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
30094 // debug statements here
30096 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30098 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
30099 if(!isWasmInitialized) {
30100 throw new Error("initializeWasm() must be awaited first!");
30102 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
30103 return nativeResponseValue;
30105 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30107 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
30108 if(!isWasmInitialized) {
30109 throw new Error("initializeWasm() must be awaited first!");
30111 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
30112 // debug statements here
30114 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30116 export function NodeInfo_get_announcement_info(this_ptr: number): number {
30117 if(!isWasmInitialized) {
30118 throw new Error("initializeWasm() must be awaited first!");
30120 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
30121 return nativeResponseValue;
30123 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
30125 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
30126 if(!isWasmInitialized) {
30127 throw new Error("initializeWasm() must be awaited first!");
30129 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
30130 // debug statements here
30132 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
30134 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
30135 if(!isWasmInitialized) {
30136 throw new Error("initializeWasm() must be awaited first!");
30138 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
30139 return nativeResponseValue;
30141 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
30143 export function NodeInfo_clone_ptr(arg: number): number {
30144 if(!isWasmInitialized) {
30145 throw new Error("initializeWasm() must be awaited first!");
30147 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
30148 return nativeResponseValue;
30150 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
30152 export function NodeInfo_clone(orig: number): number {
30153 if(!isWasmInitialized) {
30154 throw new Error("initializeWasm() must be awaited first!");
30156 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
30157 return nativeResponseValue;
30159 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
30161 export function NodeInfo_write(obj: number): number {
30162 if(!isWasmInitialized) {
30163 throw new Error("initializeWasm() must be awaited first!");
30165 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
30166 return nativeResponseValue;
30168 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
30170 export function NodeInfo_read(ser: number): number {
30171 if(!isWasmInitialized) {
30172 throw new Error("initializeWasm() must be awaited first!");
30174 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
30175 return nativeResponseValue;
30177 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
30179 export function NetworkGraph_write(obj: number): number {
30180 if(!isWasmInitialized) {
30181 throw new Error("initializeWasm() must be awaited first!");
30183 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
30184 return nativeResponseValue;
30186 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
30188 export function NetworkGraph_read(ser: number, arg: number): number {
30189 if(!isWasmInitialized) {
30190 throw new Error("initializeWasm() must be awaited first!");
30192 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
30193 return nativeResponseValue;
30195 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
30197 export function NetworkGraph_new(genesis_hash: number, logger: number): number {
30198 if(!isWasmInitialized) {
30199 throw new Error("initializeWasm() must be awaited first!");
30201 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
30202 return nativeResponseValue;
30204 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30206 export function NetworkGraph_read_only(this_arg: number): number {
30207 if(!isWasmInitialized) {
30208 throw new Error("initializeWasm() must be awaited first!");
30210 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
30211 return nativeResponseValue;
30213 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30215 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: number): number {
30216 if(!isWasmInitialized) {
30217 throw new Error("initializeWasm() must be awaited first!");
30219 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
30220 return nativeResponseValue;
30222 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
30224 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: number, last_rapid_gossip_sync_timestamp: number): void {
30225 if(!isWasmInitialized) {
30226 throw new Error("initializeWasm() must be awaited first!");
30228 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
30229 // debug statements here
30231 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
30233 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
30234 if(!isWasmInitialized) {
30235 throw new Error("initializeWasm() must be awaited first!");
30237 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
30238 return nativeResponseValue;
30240 // 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);
30242 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
30243 if(!isWasmInitialized) {
30244 throw new Error("initializeWasm() must be awaited first!");
30246 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
30247 return nativeResponseValue;
30249 // 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);
30251 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
30252 if(!isWasmInitialized) {
30253 throw new Error("initializeWasm() must be awaited first!");
30255 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
30256 return nativeResponseValue;
30258 // 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);
30260 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
30261 if(!isWasmInitialized) {
30262 throw new Error("initializeWasm() must be awaited first!");
30264 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
30265 return nativeResponseValue;
30267 // 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);
30269 export function NetworkGraph_add_channel_from_partial_announcement(this_arg: number, short_channel_id: bigint, timestamp: bigint, features: number, node_id_1: number, node_id_2: number): number {
30270 if(!isWasmInitialized) {
30271 throw new Error("initializeWasm() must be awaited first!");
30273 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
30274 return nativeResponseValue;
30276 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
30278 export function NetworkGraph_channel_failed(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
30279 if(!isWasmInitialized) {
30280 throw new Error("initializeWasm() must be awaited first!");
30282 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
30283 // debug statements here
30285 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
30287 export function NetworkGraph_node_failed(this_arg: number, _node_id: number, is_permanent: boolean): void {
30288 if(!isWasmInitialized) {
30289 throw new Error("initializeWasm() must be awaited first!");
30291 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
30292 // debug statements here
30294 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
30296 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
30297 if(!isWasmInitialized) {
30298 throw new Error("initializeWasm() must be awaited first!");
30300 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
30301 // debug statements here
30303 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
30305 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
30306 if(!isWasmInitialized) {
30307 throw new Error("initializeWasm() must be awaited first!");
30309 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
30310 return nativeResponseValue;
30312 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
30314 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
30315 if(!isWasmInitialized) {
30316 throw new Error("initializeWasm() must be awaited first!");
30318 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
30319 return nativeResponseValue;
30321 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
30323 export function ReadOnlyNetworkGraph_channel(this_arg: number, short_channel_id: bigint): number {
30324 if(!isWasmInitialized) {
30325 throw new Error("initializeWasm() must be awaited first!");
30327 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
30328 return nativeResponseValue;
30330 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
30332 export function ReadOnlyNetworkGraph_list_channels(this_arg: number): number {
30333 if(!isWasmInitialized) {
30334 throw new Error("initializeWasm() must be awaited first!");
30336 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
30337 return nativeResponseValue;
30339 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30341 export function ReadOnlyNetworkGraph_node(this_arg: number, node_id: number): number {
30342 if(!isWasmInitialized) {
30343 throw new Error("initializeWasm() must be awaited first!");
30345 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
30346 return nativeResponseValue;
30348 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
30350 export function ReadOnlyNetworkGraph_list_nodes(this_arg: number): number {
30351 if(!isWasmInitialized) {
30352 throw new Error("initializeWasm() must be awaited first!");
30354 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
30355 return nativeResponseValue;
30357 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
30359 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
30360 if(!isWasmInitialized) {
30361 throw new Error("initializeWasm() must be awaited first!");
30363 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
30364 return nativeResponseValue;
30366 // void RouteHop_free(struct LDKRouteHop this_obj);
30368 export function RouteHop_free(this_obj: number): void {
30369 if(!isWasmInitialized) {
30370 throw new Error("initializeWasm() must be awaited first!");
30372 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
30373 // debug statements here
30375 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30377 export function RouteHop_get_pubkey(this_ptr: number): number {
30378 if(!isWasmInitialized) {
30379 throw new Error("initializeWasm() must be awaited first!");
30381 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
30382 return nativeResponseValue;
30384 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30386 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
30387 if(!isWasmInitialized) {
30388 throw new Error("initializeWasm() must be awaited first!");
30390 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
30391 // debug statements here
30393 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30395 export function RouteHop_get_node_features(this_ptr: number): number {
30396 if(!isWasmInitialized) {
30397 throw new Error("initializeWasm() must be awaited first!");
30399 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
30400 return nativeResponseValue;
30402 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
30404 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
30405 if(!isWasmInitialized) {
30406 throw new Error("initializeWasm() must be awaited first!");
30408 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
30409 // debug statements here
30411 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30413 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
30414 if(!isWasmInitialized) {
30415 throw new Error("initializeWasm() must be awaited first!");
30417 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
30418 return nativeResponseValue;
30420 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
30422 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
30423 if(!isWasmInitialized) {
30424 throw new Error("initializeWasm() must be awaited first!");
30426 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
30427 // debug statements here
30429 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30431 export function RouteHop_get_channel_features(this_ptr: number): number {
30432 if(!isWasmInitialized) {
30433 throw new Error("initializeWasm() must be awaited first!");
30435 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
30436 return nativeResponseValue;
30438 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
30440 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
30441 if(!isWasmInitialized) {
30442 throw new Error("initializeWasm() must be awaited first!");
30444 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
30445 // debug statements here
30447 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30449 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
30450 if(!isWasmInitialized) {
30451 throw new Error("initializeWasm() must be awaited first!");
30453 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
30454 return nativeResponseValue;
30456 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
30458 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
30459 if(!isWasmInitialized) {
30460 throw new Error("initializeWasm() must be awaited first!");
30462 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
30463 // debug statements here
30465 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30467 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
30468 if(!isWasmInitialized) {
30469 throw new Error("initializeWasm() must be awaited first!");
30471 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
30472 return nativeResponseValue;
30474 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
30476 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
30477 if(!isWasmInitialized) {
30478 throw new Error("initializeWasm() must be awaited first!");
30480 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
30481 // debug statements here
30483 // 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);
30485 export function RouteHop_new(pubkey_arg: number, node_features_arg: number, short_channel_id_arg: bigint, channel_features_arg: number, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): number {
30486 if(!isWasmInitialized) {
30487 throw new Error("initializeWasm() must be awaited first!");
30489 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);
30490 return nativeResponseValue;
30492 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
30494 export function RouteHop_clone_ptr(arg: number): number {
30495 if(!isWasmInitialized) {
30496 throw new Error("initializeWasm() must be awaited first!");
30498 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
30499 return nativeResponseValue;
30501 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
30503 export function RouteHop_clone(orig: number): number {
30504 if(!isWasmInitialized) {
30505 throw new Error("initializeWasm() must be awaited first!");
30507 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
30508 return nativeResponseValue;
30510 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
30512 export function RouteHop_hash(o: number): bigint {
30513 if(!isWasmInitialized) {
30514 throw new Error("initializeWasm() must be awaited first!");
30516 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
30517 return nativeResponseValue;
30519 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
30521 export function RouteHop_eq(a: number, b: number): boolean {
30522 if(!isWasmInitialized) {
30523 throw new Error("initializeWasm() must be awaited first!");
30525 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
30526 return nativeResponseValue;
30528 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
30530 export function RouteHop_write(obj: number): number {
30531 if(!isWasmInitialized) {
30532 throw new Error("initializeWasm() must be awaited first!");
30534 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
30535 return nativeResponseValue;
30537 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
30539 export function RouteHop_read(ser: number): number {
30540 if(!isWasmInitialized) {
30541 throw new Error("initializeWasm() must be awaited first!");
30543 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
30544 return nativeResponseValue;
30546 // void Route_free(struct LDKRoute this_obj);
30548 export function Route_free(this_obj: number): void {
30549 if(!isWasmInitialized) {
30550 throw new Error("initializeWasm() must be awaited first!");
30552 const nativeResponseValue = wasm.TS_Route_free(this_obj);
30553 // debug statements here
30555 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
30557 export function Route_get_paths(this_ptr: number): number {
30558 if(!isWasmInitialized) {
30559 throw new Error("initializeWasm() must be awaited first!");
30561 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
30562 return nativeResponseValue;
30564 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
30566 export function Route_set_paths(this_ptr: number, val: number): void {
30567 if(!isWasmInitialized) {
30568 throw new Error("initializeWasm() must be awaited first!");
30570 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
30571 // debug statements here
30573 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
30575 export function Route_get_payment_params(this_ptr: number): number {
30576 if(!isWasmInitialized) {
30577 throw new Error("initializeWasm() must be awaited first!");
30579 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
30580 return nativeResponseValue;
30582 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30584 export function Route_set_payment_params(this_ptr: number, val: number): void {
30585 if(!isWasmInitialized) {
30586 throw new Error("initializeWasm() must be awaited first!");
30588 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
30589 // debug statements here
30591 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
30593 export function Route_new(paths_arg: number, payment_params_arg: number): number {
30594 if(!isWasmInitialized) {
30595 throw new Error("initializeWasm() must be awaited first!");
30597 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
30598 return nativeResponseValue;
30600 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
30602 export function Route_clone_ptr(arg: number): number {
30603 if(!isWasmInitialized) {
30604 throw new Error("initializeWasm() must be awaited first!");
30606 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
30607 return nativeResponseValue;
30609 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
30611 export function Route_clone(orig: number): number {
30612 if(!isWasmInitialized) {
30613 throw new Error("initializeWasm() must be awaited first!");
30615 const nativeResponseValue = wasm.TS_Route_clone(orig);
30616 return nativeResponseValue;
30618 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
30620 export function Route_hash(o: number): bigint {
30621 if(!isWasmInitialized) {
30622 throw new Error("initializeWasm() must be awaited first!");
30624 const nativeResponseValue = wasm.TS_Route_hash(o);
30625 return nativeResponseValue;
30627 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
30629 export function Route_eq(a: number, b: number): boolean {
30630 if(!isWasmInitialized) {
30631 throw new Error("initializeWasm() must be awaited first!");
30633 const nativeResponseValue = wasm.TS_Route_eq(a, b);
30634 return nativeResponseValue;
30636 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
30638 export function Route_get_total_fees(this_arg: number): bigint {
30639 if(!isWasmInitialized) {
30640 throw new Error("initializeWasm() must be awaited first!");
30642 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
30643 return nativeResponseValue;
30645 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
30647 export function Route_get_total_amount(this_arg: number): bigint {
30648 if(!isWasmInitialized) {
30649 throw new Error("initializeWasm() must be awaited first!");
30651 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
30652 return nativeResponseValue;
30654 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
30656 export function Route_write(obj: number): number {
30657 if(!isWasmInitialized) {
30658 throw new Error("initializeWasm() must be awaited first!");
30660 const nativeResponseValue = wasm.TS_Route_write(obj);
30661 return nativeResponseValue;
30663 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
30665 export function Route_read(ser: number): number {
30666 if(!isWasmInitialized) {
30667 throw new Error("initializeWasm() must be awaited first!");
30669 const nativeResponseValue = wasm.TS_Route_read(ser);
30670 return nativeResponseValue;
30672 // void RouteParameters_free(struct LDKRouteParameters this_obj);
30674 export function RouteParameters_free(this_obj: number): void {
30675 if(!isWasmInitialized) {
30676 throw new Error("initializeWasm() must be awaited first!");
30678 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
30679 // debug statements here
30681 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30683 export function RouteParameters_get_payment_params(this_ptr: number): number {
30684 if(!isWasmInitialized) {
30685 throw new Error("initializeWasm() must be awaited first!");
30687 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
30688 return nativeResponseValue;
30690 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30692 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
30693 if(!isWasmInitialized) {
30694 throw new Error("initializeWasm() must be awaited first!");
30696 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
30697 // debug statements here
30699 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30701 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
30702 if(!isWasmInitialized) {
30703 throw new Error("initializeWasm() must be awaited first!");
30705 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
30706 return nativeResponseValue;
30708 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
30710 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
30711 if(!isWasmInitialized) {
30712 throw new Error("initializeWasm() must be awaited first!");
30714 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
30715 // debug statements here
30717 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30719 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
30720 if(!isWasmInitialized) {
30721 throw new Error("initializeWasm() must be awaited first!");
30723 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
30724 return nativeResponseValue;
30726 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
30728 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
30729 if(!isWasmInitialized) {
30730 throw new Error("initializeWasm() must be awaited first!");
30732 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
30733 // debug statements here
30735 // 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);
30737 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
30738 if(!isWasmInitialized) {
30739 throw new Error("initializeWasm() must be awaited first!");
30741 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
30742 return nativeResponseValue;
30744 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
30746 export function RouteParameters_clone_ptr(arg: number): number {
30747 if(!isWasmInitialized) {
30748 throw new Error("initializeWasm() must be awaited first!");
30750 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
30751 return nativeResponseValue;
30753 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
30755 export function RouteParameters_clone(orig: number): number {
30756 if(!isWasmInitialized) {
30757 throw new Error("initializeWasm() must be awaited first!");
30759 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
30760 return nativeResponseValue;
30762 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
30764 export function RouteParameters_write(obj: number): number {
30765 if(!isWasmInitialized) {
30766 throw new Error("initializeWasm() must be awaited first!");
30768 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
30769 return nativeResponseValue;
30771 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
30773 export function RouteParameters_read(ser: number): number {
30774 if(!isWasmInitialized) {
30775 throw new Error("initializeWasm() must be awaited first!");
30777 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
30778 return nativeResponseValue;
30780 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
30782 export function PaymentParameters_free(this_obj: number): void {
30783 if(!isWasmInitialized) {
30784 throw new Error("initializeWasm() must be awaited first!");
30786 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
30787 // debug statements here
30789 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30791 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
30792 if(!isWasmInitialized) {
30793 throw new Error("initializeWasm() must be awaited first!");
30795 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
30796 return nativeResponseValue;
30798 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30800 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
30801 if(!isWasmInitialized) {
30802 throw new Error("initializeWasm() must be awaited first!");
30804 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
30805 // debug statements here
30807 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30809 export function PaymentParameters_get_features(this_ptr: number): number {
30810 if(!isWasmInitialized) {
30811 throw new Error("initializeWasm() must be awaited first!");
30813 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
30814 return nativeResponseValue;
30816 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
30818 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
30819 if(!isWasmInitialized) {
30820 throw new Error("initializeWasm() must be awaited first!");
30822 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
30823 // debug statements here
30825 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30827 export function PaymentParameters_get_route_hints(this_ptr: number): number {
30828 if(!isWasmInitialized) {
30829 throw new Error("initializeWasm() must be awaited first!");
30831 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
30832 return nativeResponseValue;
30834 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
30836 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
30837 if(!isWasmInitialized) {
30838 throw new Error("initializeWasm() must be awaited first!");
30840 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
30841 // debug statements here
30843 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30845 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
30846 if(!isWasmInitialized) {
30847 throw new Error("initializeWasm() must be awaited first!");
30849 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
30850 return nativeResponseValue;
30852 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30854 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
30855 if(!isWasmInitialized) {
30856 throw new Error("initializeWasm() must be awaited first!");
30858 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
30859 // debug statements here
30861 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30863 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
30864 if(!isWasmInitialized) {
30865 throw new Error("initializeWasm() must be awaited first!");
30867 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
30868 return nativeResponseValue;
30870 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
30872 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
30873 if(!isWasmInitialized) {
30874 throw new Error("initializeWasm() must be awaited first!");
30876 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
30877 // debug statements here
30879 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30881 export function PaymentParameters_get_max_path_count(this_ptr: number): number {
30882 if(!isWasmInitialized) {
30883 throw new Error("initializeWasm() must be awaited first!");
30885 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
30886 return nativeResponseValue;
30888 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30890 export function PaymentParameters_set_max_path_count(this_ptr: number, val: number): void {
30891 if(!isWasmInitialized) {
30892 throw new Error("initializeWasm() must be awaited first!");
30894 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
30895 // debug statements here
30897 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30899 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: number): number {
30900 if(!isWasmInitialized) {
30901 throw new Error("initializeWasm() must be awaited first!");
30903 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
30904 return nativeResponseValue;
30906 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30908 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: number, val: number): void {
30909 if(!isWasmInitialized) {
30910 throw new Error("initializeWasm() must be awaited first!");
30912 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
30913 // debug statements here
30915 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30917 export function PaymentParameters_get_previously_failed_channels(this_ptr: number): number {
30918 if(!isWasmInitialized) {
30919 throw new Error("initializeWasm() must be awaited first!");
30921 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
30922 return nativeResponseValue;
30924 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
30926 export function PaymentParameters_set_previously_failed_channels(this_ptr: number, val: number): void {
30927 if(!isWasmInitialized) {
30928 throw new Error("initializeWasm() must be awaited first!");
30930 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
30931 // debug statements here
30933 // 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);
30935 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: number, route_hints_arg: number, expiry_time_arg: number, 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): number {
30936 if(!isWasmInitialized) {
30937 throw new Error("initializeWasm() must be awaited first!");
30939 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);
30940 return nativeResponseValue;
30942 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
30944 export function PaymentParameters_clone_ptr(arg: number): number {
30945 if(!isWasmInitialized) {
30946 throw new Error("initializeWasm() must be awaited first!");
30948 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
30949 return nativeResponseValue;
30951 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
30953 export function PaymentParameters_clone(orig: number): number {
30954 if(!isWasmInitialized) {
30955 throw new Error("initializeWasm() must be awaited first!");
30957 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
30958 return nativeResponseValue;
30960 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
30962 export function PaymentParameters_hash(o: number): bigint {
30963 if(!isWasmInitialized) {
30964 throw new Error("initializeWasm() must be awaited first!");
30966 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
30967 return nativeResponseValue;
30969 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
30971 export function PaymentParameters_eq(a: number, b: number): boolean {
30972 if(!isWasmInitialized) {
30973 throw new Error("initializeWasm() must be awaited first!");
30975 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
30976 return nativeResponseValue;
30978 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
30980 export function PaymentParameters_write(obj: number): number {
30981 if(!isWasmInitialized) {
30982 throw new Error("initializeWasm() must be awaited first!");
30984 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
30985 return nativeResponseValue;
30987 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
30989 export function PaymentParameters_read(ser: number): number {
30990 if(!isWasmInitialized) {
30991 throw new Error("initializeWasm() must be awaited first!");
30993 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
30994 return nativeResponseValue;
30996 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
30998 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
30999 if(!isWasmInitialized) {
31000 throw new Error("initializeWasm() must be awaited first!");
31002 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
31003 return nativeResponseValue;
31005 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
31007 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
31008 if(!isWasmInitialized) {
31009 throw new Error("initializeWasm() must be awaited first!");
31011 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
31012 return nativeResponseValue;
31014 // void RouteHint_free(struct LDKRouteHint this_obj);
31016 export function RouteHint_free(this_obj: number): void {
31017 if(!isWasmInitialized) {
31018 throw new Error("initializeWasm() must be awaited first!");
31020 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
31021 // debug statements here
31023 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
31025 export function RouteHint_get_a(this_ptr: number): number {
31026 if(!isWasmInitialized) {
31027 throw new Error("initializeWasm() must be awaited first!");
31029 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
31030 return nativeResponseValue;
31032 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
31034 export function RouteHint_set_a(this_ptr: number, val: number): void {
31035 if(!isWasmInitialized) {
31036 throw new Error("initializeWasm() must be awaited first!");
31038 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
31039 // debug statements here
31041 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
31043 export function RouteHint_new(a_arg: number): number {
31044 if(!isWasmInitialized) {
31045 throw new Error("initializeWasm() must be awaited first!");
31047 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
31048 return nativeResponseValue;
31050 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
31052 export function RouteHint_clone_ptr(arg: number): number {
31053 if(!isWasmInitialized) {
31054 throw new Error("initializeWasm() must be awaited first!");
31056 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
31057 return nativeResponseValue;
31059 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
31061 export function RouteHint_clone(orig: number): number {
31062 if(!isWasmInitialized) {
31063 throw new Error("initializeWasm() must be awaited first!");
31065 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
31066 return nativeResponseValue;
31068 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
31070 export function RouteHint_hash(o: number): bigint {
31071 if(!isWasmInitialized) {
31072 throw new Error("initializeWasm() must be awaited first!");
31074 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
31075 return nativeResponseValue;
31077 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
31079 export function RouteHint_eq(a: number, b: number): boolean {
31080 if(!isWasmInitialized) {
31081 throw new Error("initializeWasm() must be awaited first!");
31083 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
31084 return nativeResponseValue;
31086 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
31088 export function RouteHint_write(obj: number): number {
31089 if(!isWasmInitialized) {
31090 throw new Error("initializeWasm() must be awaited first!");
31092 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
31093 return nativeResponseValue;
31095 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
31097 export function RouteHint_read(ser: number): number {
31098 if(!isWasmInitialized) {
31099 throw new Error("initializeWasm() must be awaited first!");
31101 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
31102 return nativeResponseValue;
31104 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
31106 export function RouteHintHop_free(this_obj: number): void {
31107 if(!isWasmInitialized) {
31108 throw new Error("initializeWasm() must be awaited first!");
31110 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
31111 // debug statements here
31113 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31115 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
31116 if(!isWasmInitialized) {
31117 throw new Error("initializeWasm() must be awaited first!");
31119 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
31120 return nativeResponseValue;
31122 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31124 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
31125 if(!isWasmInitialized) {
31126 throw new Error("initializeWasm() must be awaited first!");
31128 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
31129 // debug statements here
31131 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31133 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
31134 if(!isWasmInitialized) {
31135 throw new Error("initializeWasm() must be awaited first!");
31137 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
31138 return nativeResponseValue;
31140 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
31142 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
31143 if(!isWasmInitialized) {
31144 throw new Error("initializeWasm() must be awaited first!");
31146 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
31147 // debug statements here
31149 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31151 export function RouteHintHop_get_fees(this_ptr: number): number {
31152 if(!isWasmInitialized) {
31153 throw new Error("initializeWasm() must be awaited first!");
31155 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
31156 return nativeResponseValue;
31158 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
31160 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
31161 if(!isWasmInitialized) {
31162 throw new Error("initializeWasm() must be awaited first!");
31164 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
31165 // debug statements here
31167 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31169 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
31170 if(!isWasmInitialized) {
31171 throw new Error("initializeWasm() must be awaited first!");
31173 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
31174 return nativeResponseValue;
31176 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
31178 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
31179 if(!isWasmInitialized) {
31180 throw new Error("initializeWasm() must be awaited first!");
31182 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
31183 // debug statements here
31185 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31187 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
31188 if(!isWasmInitialized) {
31189 throw new Error("initializeWasm() must be awaited first!");
31191 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
31192 return nativeResponseValue;
31194 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31196 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
31197 if(!isWasmInitialized) {
31198 throw new Error("initializeWasm() must be awaited first!");
31200 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
31201 // debug statements here
31203 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31205 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
31206 if(!isWasmInitialized) {
31207 throw new Error("initializeWasm() must be awaited first!");
31209 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
31210 return nativeResponseValue;
31212 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31214 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
31215 if(!isWasmInitialized) {
31216 throw new Error("initializeWasm() must be awaited first!");
31218 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
31219 // debug statements here
31221 // 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);
31223 export function RouteHintHop_new(src_node_id_arg: number, short_channel_id_arg: bigint, fees_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number, htlc_maximum_msat_arg: number): number {
31224 if(!isWasmInitialized) {
31225 throw new Error("initializeWasm() must be awaited first!");
31227 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);
31228 return nativeResponseValue;
31230 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
31232 export function RouteHintHop_clone_ptr(arg: number): number {
31233 if(!isWasmInitialized) {
31234 throw new Error("initializeWasm() must be awaited first!");
31236 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
31237 return nativeResponseValue;
31239 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
31241 export function RouteHintHop_clone(orig: number): number {
31242 if(!isWasmInitialized) {
31243 throw new Error("initializeWasm() must be awaited first!");
31245 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
31246 return nativeResponseValue;
31248 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
31250 export function RouteHintHop_hash(o: number): bigint {
31251 if(!isWasmInitialized) {
31252 throw new Error("initializeWasm() must be awaited first!");
31254 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
31255 return nativeResponseValue;
31257 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
31259 export function RouteHintHop_eq(a: number, b: number): boolean {
31260 if(!isWasmInitialized) {
31261 throw new Error("initializeWasm() must be awaited first!");
31263 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
31264 return nativeResponseValue;
31266 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
31268 export function RouteHintHop_write(obj: number): number {
31269 if(!isWasmInitialized) {
31270 throw new Error("initializeWasm() must be awaited first!");
31272 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
31273 return nativeResponseValue;
31275 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
31277 export function RouteHintHop_read(ser: number): number {
31278 if(!isWasmInitialized) {
31279 throw new Error("initializeWasm() must be awaited first!");
31281 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
31282 return nativeResponseValue;
31284 // 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]);
31286 export function find_route(our_node_pubkey: number, route_params: number, network_graph: number, first_hops: number, logger: number, scorer: number, random_seed_bytes: number): number {
31287 if(!isWasmInitialized) {
31288 throw new Error("initializeWasm() must be awaited first!");
31290 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
31291 return nativeResponseValue;
31293 // 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]);
31295 export function build_route_from_hops(our_node_pubkey: number, hops: number, route_params: number, network_graph: number, logger: number, random_seed_bytes: number): number {
31296 if(!isWasmInitialized) {
31297 throw new Error("initializeWasm() must be awaited first!");
31299 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
31300 return nativeResponseValue;
31302 // void Score_free(struct LDKScore this_ptr);
31304 export function Score_free(this_ptr: number): void {
31305 if(!isWasmInitialized) {
31306 throw new Error("initializeWasm() must be awaited first!");
31308 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
31309 // debug statements here
31311 // void LockableScore_free(struct LDKLockableScore this_ptr);
31313 export function LockableScore_free(this_ptr: number): void {
31314 if(!isWasmInitialized) {
31315 throw new Error("initializeWasm() must be awaited first!");
31317 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
31318 // debug statements here
31320 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
31322 export function MultiThreadedLockableScore_free(this_obj: number): void {
31323 if(!isWasmInitialized) {
31324 throw new Error("initializeWasm() must be awaited first!");
31326 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
31327 // debug statements here
31329 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
31331 export function MultiThreadedLockableScore_write(obj: number): number {
31332 if(!isWasmInitialized) {
31333 throw new Error("initializeWasm() must be awaited first!");
31335 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
31336 return nativeResponseValue;
31338 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
31340 export function MultiThreadedLockableScore_new(score: number): number {
31341 if(!isWasmInitialized) {
31342 throw new Error("initializeWasm() must be awaited first!");
31344 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
31345 return nativeResponseValue;
31347 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
31349 export function ChannelUsage_free(this_obj: number): void {
31350 if(!isWasmInitialized) {
31351 throw new Error("initializeWasm() must be awaited first!");
31353 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
31354 // debug statements here
31356 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31358 export function ChannelUsage_get_amount_msat(this_ptr: number): bigint {
31359 if(!isWasmInitialized) {
31360 throw new Error("initializeWasm() must be awaited first!");
31362 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
31363 return nativeResponseValue;
31365 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
31367 export function ChannelUsage_set_amount_msat(this_ptr: number, val: bigint): void {
31368 if(!isWasmInitialized) {
31369 throw new Error("initializeWasm() must be awaited first!");
31371 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
31372 // debug statements here
31374 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31376 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: number): bigint {
31377 if(!isWasmInitialized) {
31378 throw new Error("initializeWasm() must be awaited first!");
31380 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
31381 return nativeResponseValue;
31383 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
31385 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: number, val: bigint): void {
31386 if(!isWasmInitialized) {
31387 throw new Error("initializeWasm() must be awaited first!");
31389 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
31390 // debug statements here
31392 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31394 export function ChannelUsage_get_effective_capacity(this_ptr: number): number {
31395 if(!isWasmInitialized) {
31396 throw new Error("initializeWasm() must be awaited first!");
31398 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
31399 return nativeResponseValue;
31401 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
31403 export function ChannelUsage_set_effective_capacity(this_ptr: number, val: number): void {
31404 if(!isWasmInitialized) {
31405 throw new Error("initializeWasm() must be awaited first!");
31407 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
31408 // debug statements here
31410 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
31412 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: number): number {
31413 if(!isWasmInitialized) {
31414 throw new Error("initializeWasm() must be awaited first!");
31416 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
31417 return nativeResponseValue;
31419 // uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
31421 export function ChannelUsage_clone_ptr(arg: number): number {
31422 if(!isWasmInitialized) {
31423 throw new Error("initializeWasm() must be awaited first!");
31425 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
31426 return nativeResponseValue;
31428 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
31430 export function ChannelUsage_clone(orig: number): number {
31431 if(!isWasmInitialized) {
31432 throw new Error("initializeWasm() must be awaited first!");
31434 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
31435 return nativeResponseValue;
31437 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
31439 export function FixedPenaltyScorer_free(this_obj: number): void {
31440 if(!isWasmInitialized) {
31441 throw new Error("initializeWasm() must be awaited first!");
31443 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
31444 // debug statements here
31446 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
31448 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
31449 if(!isWasmInitialized) {
31450 throw new Error("initializeWasm() must be awaited first!");
31452 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
31453 return nativeResponseValue;
31455 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
31457 export function FixedPenaltyScorer_clone(orig: number): number {
31458 if(!isWasmInitialized) {
31459 throw new Error("initializeWasm() must be awaited first!");
31461 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
31462 return nativeResponseValue;
31464 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
31466 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
31467 if(!isWasmInitialized) {
31468 throw new Error("initializeWasm() must be awaited first!");
31470 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
31471 return nativeResponseValue;
31473 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
31475 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
31476 if(!isWasmInitialized) {
31477 throw new Error("initializeWasm() must be awaited first!");
31479 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
31480 return nativeResponseValue;
31482 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
31484 export function FixedPenaltyScorer_write(obj: number): number {
31485 if(!isWasmInitialized) {
31486 throw new Error("initializeWasm() must be awaited first!");
31488 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
31489 return nativeResponseValue;
31491 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
31493 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
31494 if(!isWasmInitialized) {
31495 throw new Error("initializeWasm() must be awaited first!");
31497 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
31498 return nativeResponseValue;
31500 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
31502 export function ProbabilisticScorer_free(this_obj: number): void {
31503 if(!isWasmInitialized) {
31504 throw new Error("initializeWasm() must be awaited first!");
31506 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
31507 // debug statements here
31509 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
31511 export function ProbabilisticScoringParameters_free(this_obj: number): void {
31512 if(!isWasmInitialized) {
31513 throw new Error("initializeWasm() must be awaited first!");
31515 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
31516 // debug statements here
31518 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31520 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
31521 if(!isWasmInitialized) {
31522 throw new Error("initializeWasm() must be awaited first!");
31524 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
31525 return nativeResponseValue;
31527 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31529 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
31530 if(!isWasmInitialized) {
31531 throw new Error("initializeWasm() must be awaited first!");
31533 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
31534 // debug statements here
31536 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31538 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: number): bigint {
31539 if(!isWasmInitialized) {
31540 throw new Error("initializeWasm() must be awaited first!");
31542 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
31543 return nativeResponseValue;
31545 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31547 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: number, val: bigint): void {
31548 if(!isWasmInitialized) {
31549 throw new Error("initializeWasm() must be awaited first!");
31551 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
31552 // debug statements here
31554 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31556 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
31557 if(!isWasmInitialized) {
31558 throw new Error("initializeWasm() must be awaited first!");
31560 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
31561 return nativeResponseValue;
31563 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31565 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
31566 if(!isWasmInitialized) {
31567 throw new Error("initializeWasm() must be awaited first!");
31569 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
31570 // debug statements here
31572 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31574 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
31575 if(!isWasmInitialized) {
31576 throw new Error("initializeWasm() must be awaited first!");
31578 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
31579 return nativeResponseValue;
31581 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31583 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
31584 if(!isWasmInitialized) {
31585 throw new Error("initializeWasm() must be awaited first!");
31587 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
31588 // debug statements here
31590 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31592 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: number): bigint {
31593 if(!isWasmInitialized) {
31594 throw new Error("initializeWasm() must be awaited first!");
31596 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
31597 return nativeResponseValue;
31599 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31601 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: number, val: bigint): void {
31602 if(!isWasmInitialized) {
31603 throw new Error("initializeWasm() must be awaited first!");
31605 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
31606 // debug statements here
31608 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31610 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: number): bigint {
31611 if(!isWasmInitialized) {
31612 throw new Error("initializeWasm() must be awaited first!");
31614 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
31615 return nativeResponseValue;
31617 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31619 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: number, val: bigint): void {
31620 if(!isWasmInitialized) {
31621 throw new Error("initializeWasm() must be awaited first!");
31623 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
31624 // debug statements here
31626 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31628 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: number): bigint {
31629 if(!isWasmInitialized) {
31630 throw new Error("initializeWasm() must be awaited first!");
31632 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
31633 return nativeResponseValue;
31635 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31637 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: number, val: bigint): void {
31638 if(!isWasmInitialized) {
31639 throw new Error("initializeWasm() must be awaited first!");
31641 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
31642 // debug statements here
31644 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
31646 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
31647 if(!isWasmInitialized) {
31648 throw new Error("initializeWasm() must be awaited first!");
31650 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
31651 return nativeResponseValue;
31653 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
31655 export function ProbabilisticScoringParameters_clone(orig: number): number {
31656 if(!isWasmInitialized) {
31657 throw new Error("initializeWasm() must be awaited first!");
31659 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
31660 return nativeResponseValue;
31662 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
31664 export function ProbabilisticScorer_new(params: number, network_graph: number, logger: number): number {
31665 if(!isWasmInitialized) {
31666 throw new Error("initializeWasm() must be awaited first!");
31668 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
31669 return nativeResponseValue;
31671 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31673 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: number): void {
31674 if(!isWasmInitialized) {
31675 throw new Error("initializeWasm() must be awaited first!");
31677 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
31678 // debug statements here
31680 // 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);
31682 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: number, scid: bigint, target: number): number {
31683 if(!isWasmInitialized) {
31684 throw new Error("initializeWasm() must be awaited first!");
31686 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
31687 return nativeResponseValue;
31689 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31691 export function ProbabilisticScorer_add_banned(this_arg: number, node_id: number): void {
31692 if(!isWasmInitialized) {
31693 throw new Error("initializeWasm() must be awaited first!");
31695 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
31696 // debug statements here
31698 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31700 export function ProbabilisticScorer_remove_banned(this_arg: number, node_id: number): void {
31701 if(!isWasmInitialized) {
31702 throw new Error("initializeWasm() must be awaited first!");
31704 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
31705 // debug statements here
31707 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
31709 export function ProbabilisticScorer_set_manual_penalty(this_arg: number, node_id: number, penalty: bigint): void {
31710 if(!isWasmInitialized) {
31711 throw new Error("initializeWasm() must be awaited first!");
31713 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
31714 // debug statements here
31716 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31718 export function ProbabilisticScorer_remove_manual_penalty(this_arg: number, node_id: number): void {
31719 if(!isWasmInitialized) {
31720 throw new Error("initializeWasm() must be awaited first!");
31722 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
31723 // debug statements here
31725 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31727 export function ProbabilisticScorer_clear_manual_penalties(this_arg: number): void {
31728 if(!isWasmInitialized) {
31729 throw new Error("initializeWasm() must be awaited first!");
31731 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
31732 // debug statements here
31734 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
31736 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: number, node_ids: number): void {
31737 if(!isWasmInitialized) {
31738 throw new Error("initializeWasm() must be awaited first!");
31740 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
31741 // debug statements here
31743 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
31745 export function ProbabilisticScoringParameters_default(): number {
31746 if(!isWasmInitialized) {
31747 throw new Error("initializeWasm() must be awaited first!");
31749 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
31750 return nativeResponseValue;
31752 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31754 export function ProbabilisticScorer_as_Score(this_arg: number): number {
31755 if(!isWasmInitialized) {
31756 throw new Error("initializeWasm() must be awaited first!");
31758 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
31759 return nativeResponseValue;
31761 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
31763 export function ProbabilisticScorer_write(obj: number): number {
31764 if(!isWasmInitialized) {
31765 throw new Error("initializeWasm() must be awaited first!");
31767 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
31768 return nativeResponseValue;
31770 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
31772 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number, arg_c: number): number {
31773 if(!isWasmInitialized) {
31774 throw new Error("initializeWasm() must be awaited first!");
31776 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
31777 return nativeResponseValue;
31779 // void ParseError_free(struct LDKParseError this_ptr);
31781 export function ParseError_free(this_ptr: number): void {
31782 if(!isWasmInitialized) {
31783 throw new Error("initializeWasm() must be awaited first!");
31785 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
31786 // debug statements here
31788 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
31790 export function ParseError_clone_ptr(arg: number): number {
31791 if(!isWasmInitialized) {
31792 throw new Error("initializeWasm() must be awaited first!");
31794 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
31795 return nativeResponseValue;
31797 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
31799 export function ParseError_clone(orig: number): number {
31800 if(!isWasmInitialized) {
31801 throw new Error("initializeWasm() must be awaited first!");
31803 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
31804 return nativeResponseValue;
31806 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
31808 export function ParseError_bech32_error(a: number): number {
31809 if(!isWasmInitialized) {
31810 throw new Error("initializeWasm() must be awaited first!");
31812 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
31813 return nativeResponseValue;
31815 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
31817 export function ParseError_parse_amount_error(a: number): number {
31818 if(!isWasmInitialized) {
31819 throw new Error("initializeWasm() must be awaited first!");
31821 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
31822 return nativeResponseValue;
31824 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
31826 export function ParseError_malformed_signature(a: Secp256k1Error): number {
31827 if(!isWasmInitialized) {
31828 throw new Error("initializeWasm() must be awaited first!");
31830 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
31831 return nativeResponseValue;
31833 // struct LDKParseError ParseError_bad_prefix(void);
31835 export function ParseError_bad_prefix(): number {
31836 if(!isWasmInitialized) {
31837 throw new Error("initializeWasm() must be awaited first!");
31839 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
31840 return nativeResponseValue;
31842 // struct LDKParseError ParseError_unknown_currency(void);
31844 export function ParseError_unknown_currency(): number {
31845 if(!isWasmInitialized) {
31846 throw new Error("initializeWasm() must be awaited first!");
31848 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
31849 return nativeResponseValue;
31851 // struct LDKParseError ParseError_unknown_si_prefix(void);
31853 export function ParseError_unknown_si_prefix(): number {
31854 if(!isWasmInitialized) {
31855 throw new Error("initializeWasm() must be awaited first!");
31857 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
31858 return nativeResponseValue;
31860 // struct LDKParseError ParseError_malformed_hrp(void);
31862 export function ParseError_malformed_hrp(): number {
31863 if(!isWasmInitialized) {
31864 throw new Error("initializeWasm() must be awaited first!");
31866 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
31867 return nativeResponseValue;
31869 // struct LDKParseError ParseError_too_short_data_part(void);
31871 export function ParseError_too_short_data_part(): number {
31872 if(!isWasmInitialized) {
31873 throw new Error("initializeWasm() must be awaited first!");
31875 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
31876 return nativeResponseValue;
31878 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
31880 export function ParseError_unexpected_end_of_tagged_fields(): number {
31881 if(!isWasmInitialized) {
31882 throw new Error("initializeWasm() must be awaited first!");
31884 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
31885 return nativeResponseValue;
31887 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
31889 export function ParseError_description_decode_error(a: number): number {
31890 if(!isWasmInitialized) {
31891 throw new Error("initializeWasm() must be awaited first!");
31893 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
31894 return nativeResponseValue;
31896 // struct LDKParseError ParseError_padding_error(void);
31898 export function ParseError_padding_error(): number {
31899 if(!isWasmInitialized) {
31900 throw new Error("initializeWasm() must be awaited first!");
31902 const nativeResponseValue = wasm.TS_ParseError_padding_error();
31903 return nativeResponseValue;
31905 // struct LDKParseError ParseError_integer_overflow_error(void);
31907 export function ParseError_integer_overflow_error(): number {
31908 if(!isWasmInitialized) {
31909 throw new Error("initializeWasm() must be awaited first!");
31911 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
31912 return nativeResponseValue;
31914 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
31916 export function ParseError_invalid_seg_wit_program_length(): number {
31917 if(!isWasmInitialized) {
31918 throw new Error("initializeWasm() must be awaited first!");
31920 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
31921 return nativeResponseValue;
31923 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
31925 export function ParseError_invalid_pub_key_hash_length(): number {
31926 if(!isWasmInitialized) {
31927 throw new Error("initializeWasm() must be awaited first!");
31929 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
31930 return nativeResponseValue;
31932 // struct LDKParseError ParseError_invalid_script_hash_length(void);
31934 export function ParseError_invalid_script_hash_length(): number {
31935 if(!isWasmInitialized) {
31936 throw new Error("initializeWasm() must be awaited first!");
31938 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
31939 return nativeResponseValue;
31941 // struct LDKParseError ParseError_invalid_recovery_id(void);
31943 export function ParseError_invalid_recovery_id(): number {
31944 if(!isWasmInitialized) {
31945 throw new Error("initializeWasm() must be awaited first!");
31947 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
31948 return nativeResponseValue;
31950 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
31952 export function ParseError_invalid_slice_length(a: number): number {
31953 if(!isWasmInitialized) {
31954 throw new Error("initializeWasm() must be awaited first!");
31956 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
31957 return nativeResponseValue;
31959 // struct LDKParseError ParseError_skip(void);
31961 export function ParseError_skip(): number {
31962 if(!isWasmInitialized) {
31963 throw new Error("initializeWasm() must be awaited first!");
31965 const nativeResponseValue = wasm.TS_ParseError_skip();
31966 return nativeResponseValue;
31968 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
31970 export function ParseOrSemanticError_free(this_ptr: number): void {
31971 if(!isWasmInitialized) {
31972 throw new Error("initializeWasm() must be awaited first!");
31974 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
31975 // debug statements here
31977 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
31979 export function ParseOrSemanticError_clone_ptr(arg: number): number {
31980 if(!isWasmInitialized) {
31981 throw new Error("initializeWasm() must be awaited first!");
31983 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
31984 return nativeResponseValue;
31986 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
31988 export function ParseOrSemanticError_clone(orig: number): number {
31989 if(!isWasmInitialized) {
31990 throw new Error("initializeWasm() must be awaited first!");
31992 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
31993 return nativeResponseValue;
31995 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
31997 export function ParseOrSemanticError_parse_error(a: number): number {
31998 if(!isWasmInitialized) {
31999 throw new Error("initializeWasm() must be awaited first!");
32001 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
32002 return nativeResponseValue;
32004 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
32006 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
32007 if(!isWasmInitialized) {
32008 throw new Error("initializeWasm() must be awaited first!");
32010 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
32011 return nativeResponseValue;
32013 // void Invoice_free(struct LDKInvoice this_obj);
32015 export function Invoice_free(this_obj: number): void {
32016 if(!isWasmInitialized) {
32017 throw new Error("initializeWasm() must be awaited first!");
32019 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
32020 // debug statements here
32022 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
32024 export function Invoice_eq(a: number, b: number): boolean {
32025 if(!isWasmInitialized) {
32026 throw new Error("initializeWasm() must be awaited first!");
32028 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
32029 return nativeResponseValue;
32031 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
32033 export function Invoice_clone_ptr(arg: number): number {
32034 if(!isWasmInitialized) {
32035 throw new Error("initializeWasm() must be awaited first!");
32037 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
32038 return nativeResponseValue;
32040 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
32042 export function Invoice_clone(orig: number): number {
32043 if(!isWasmInitialized) {
32044 throw new Error("initializeWasm() must be awaited first!");
32046 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
32047 return nativeResponseValue;
32049 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
32051 export function SignedRawInvoice_free(this_obj: number): void {
32052 if(!isWasmInitialized) {
32053 throw new Error("initializeWasm() must be awaited first!");
32055 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
32056 // debug statements here
32058 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
32060 export function SignedRawInvoice_eq(a: number, b: number): boolean {
32061 if(!isWasmInitialized) {
32062 throw new Error("initializeWasm() must be awaited first!");
32064 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
32065 return nativeResponseValue;
32067 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
32069 export function SignedRawInvoice_clone_ptr(arg: number): number {
32070 if(!isWasmInitialized) {
32071 throw new Error("initializeWasm() must be awaited first!");
32073 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
32074 return nativeResponseValue;
32076 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
32078 export function SignedRawInvoice_clone(orig: number): number {
32079 if(!isWasmInitialized) {
32080 throw new Error("initializeWasm() must be awaited first!");
32082 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
32083 return nativeResponseValue;
32085 // void RawInvoice_free(struct LDKRawInvoice this_obj);
32087 export function RawInvoice_free(this_obj: number): void {
32088 if(!isWasmInitialized) {
32089 throw new Error("initializeWasm() must be awaited first!");
32091 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
32092 // debug statements here
32094 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
32096 export function RawInvoice_get_data(this_ptr: number): number {
32097 if(!isWasmInitialized) {
32098 throw new Error("initializeWasm() must be awaited first!");
32100 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
32101 return nativeResponseValue;
32103 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
32105 export function RawInvoice_set_data(this_ptr: number, val: number): void {
32106 if(!isWasmInitialized) {
32107 throw new Error("initializeWasm() must be awaited first!");
32109 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
32110 // debug statements here
32112 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
32114 export function RawInvoice_eq(a: number, b: number): boolean {
32115 if(!isWasmInitialized) {
32116 throw new Error("initializeWasm() must be awaited first!");
32118 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
32119 return nativeResponseValue;
32121 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
32123 export function RawInvoice_clone_ptr(arg: number): number {
32124 if(!isWasmInitialized) {
32125 throw new Error("initializeWasm() must be awaited first!");
32127 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
32128 return nativeResponseValue;
32130 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
32132 export function RawInvoice_clone(orig: number): number {
32133 if(!isWasmInitialized) {
32134 throw new Error("initializeWasm() must be awaited first!");
32136 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
32137 return nativeResponseValue;
32139 // void RawDataPart_free(struct LDKRawDataPart this_obj);
32141 export function RawDataPart_free(this_obj: number): void {
32142 if(!isWasmInitialized) {
32143 throw new Error("initializeWasm() must be awaited first!");
32145 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
32146 // debug statements here
32148 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
32150 export function RawDataPart_get_timestamp(this_ptr: number): number {
32151 if(!isWasmInitialized) {
32152 throw new Error("initializeWasm() must be awaited first!");
32154 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
32155 return nativeResponseValue;
32157 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
32159 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
32160 if(!isWasmInitialized) {
32161 throw new Error("initializeWasm() must be awaited first!");
32163 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
32164 // debug statements here
32166 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
32168 export function RawDataPart_eq(a: number, b: number): boolean {
32169 if(!isWasmInitialized) {
32170 throw new Error("initializeWasm() must be awaited first!");
32172 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
32173 return nativeResponseValue;
32175 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
32177 export function RawDataPart_clone_ptr(arg: number): number {
32178 if(!isWasmInitialized) {
32179 throw new Error("initializeWasm() must be awaited first!");
32181 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
32182 return nativeResponseValue;
32184 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
32186 export function RawDataPart_clone(orig: number): number {
32187 if(!isWasmInitialized) {
32188 throw new Error("initializeWasm() must be awaited first!");
32190 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
32191 return nativeResponseValue;
32193 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
32195 export function PositiveTimestamp_free(this_obj: number): void {
32196 if(!isWasmInitialized) {
32197 throw new Error("initializeWasm() must be awaited first!");
32199 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
32200 // debug statements here
32202 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
32204 export function PositiveTimestamp_eq(a: number, b: number): boolean {
32205 if(!isWasmInitialized) {
32206 throw new Error("initializeWasm() must be awaited first!");
32208 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
32209 return nativeResponseValue;
32211 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
32213 export function PositiveTimestamp_clone_ptr(arg: number): number {
32214 if(!isWasmInitialized) {
32215 throw new Error("initializeWasm() must be awaited first!");
32217 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
32218 return nativeResponseValue;
32220 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
32222 export function PositiveTimestamp_clone(orig: number): number {
32223 if(!isWasmInitialized) {
32224 throw new Error("initializeWasm() must be awaited first!");
32226 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
32227 return nativeResponseValue;
32229 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
32231 export function SiPrefix_clone(orig: number): SiPrefix {
32232 if(!isWasmInitialized) {
32233 throw new Error("initializeWasm() must be awaited first!");
32235 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
32236 return nativeResponseValue;
32238 // enum LDKSiPrefix SiPrefix_milli(void);
32240 export function SiPrefix_milli(): SiPrefix {
32241 if(!isWasmInitialized) {
32242 throw new Error("initializeWasm() must be awaited first!");
32244 const nativeResponseValue = wasm.TS_SiPrefix_milli();
32245 return nativeResponseValue;
32247 // enum LDKSiPrefix SiPrefix_micro(void);
32249 export function SiPrefix_micro(): SiPrefix {
32250 if(!isWasmInitialized) {
32251 throw new Error("initializeWasm() must be awaited first!");
32253 const nativeResponseValue = wasm.TS_SiPrefix_micro();
32254 return nativeResponseValue;
32256 // enum LDKSiPrefix SiPrefix_nano(void);
32258 export function SiPrefix_nano(): SiPrefix {
32259 if(!isWasmInitialized) {
32260 throw new Error("initializeWasm() must be awaited first!");
32262 const nativeResponseValue = wasm.TS_SiPrefix_nano();
32263 return nativeResponseValue;
32265 // enum LDKSiPrefix SiPrefix_pico(void);
32267 export function SiPrefix_pico(): SiPrefix {
32268 if(!isWasmInitialized) {
32269 throw new Error("initializeWasm() must be awaited first!");
32271 const nativeResponseValue = wasm.TS_SiPrefix_pico();
32272 return nativeResponseValue;
32274 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
32276 export function SiPrefix_eq(a: number, b: number): boolean {
32277 if(!isWasmInitialized) {
32278 throw new Error("initializeWasm() must be awaited first!");
32280 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
32281 return nativeResponseValue;
32283 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
32285 export function SiPrefix_multiplier(this_arg: number): bigint {
32286 if(!isWasmInitialized) {
32287 throw new Error("initializeWasm() must be awaited first!");
32289 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
32290 return nativeResponseValue;
32292 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
32294 export function Currency_clone(orig: number): Currency {
32295 if(!isWasmInitialized) {
32296 throw new Error("initializeWasm() must be awaited first!");
32298 const nativeResponseValue = wasm.TS_Currency_clone(orig);
32299 return nativeResponseValue;
32301 // enum LDKCurrency Currency_bitcoin(void);
32303 export function Currency_bitcoin(): Currency {
32304 if(!isWasmInitialized) {
32305 throw new Error("initializeWasm() must be awaited first!");
32307 const nativeResponseValue = wasm.TS_Currency_bitcoin();
32308 return nativeResponseValue;
32310 // enum LDKCurrency Currency_bitcoin_testnet(void);
32312 export function Currency_bitcoin_testnet(): Currency {
32313 if(!isWasmInitialized) {
32314 throw new Error("initializeWasm() must be awaited first!");
32316 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
32317 return nativeResponseValue;
32319 // enum LDKCurrency Currency_regtest(void);
32321 export function Currency_regtest(): Currency {
32322 if(!isWasmInitialized) {
32323 throw new Error("initializeWasm() must be awaited first!");
32325 const nativeResponseValue = wasm.TS_Currency_regtest();
32326 return nativeResponseValue;
32328 // enum LDKCurrency Currency_simnet(void);
32330 export function Currency_simnet(): Currency {
32331 if(!isWasmInitialized) {
32332 throw new Error("initializeWasm() must be awaited first!");
32334 const nativeResponseValue = wasm.TS_Currency_simnet();
32335 return nativeResponseValue;
32337 // enum LDKCurrency Currency_signet(void);
32339 export function Currency_signet(): Currency {
32340 if(!isWasmInitialized) {
32341 throw new Error("initializeWasm() must be awaited first!");
32343 const nativeResponseValue = wasm.TS_Currency_signet();
32344 return nativeResponseValue;
32346 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
32348 export function Currency_hash(o: number): bigint {
32349 if(!isWasmInitialized) {
32350 throw new Error("initializeWasm() must be awaited first!");
32352 const nativeResponseValue = wasm.TS_Currency_hash(o);
32353 return nativeResponseValue;
32355 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
32357 export function Currency_eq(a: number, b: number): boolean {
32358 if(!isWasmInitialized) {
32359 throw new Error("initializeWasm() must be awaited first!");
32361 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
32362 return nativeResponseValue;
32364 // void Sha256_free(struct LDKSha256 this_obj);
32366 export function Sha256_free(this_obj: number): void {
32367 if(!isWasmInitialized) {
32368 throw new Error("initializeWasm() must be awaited first!");
32370 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
32371 // debug statements here
32373 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
32375 export function Sha256_clone_ptr(arg: number): number {
32376 if(!isWasmInitialized) {
32377 throw new Error("initializeWasm() must be awaited first!");
32379 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
32380 return nativeResponseValue;
32382 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
32384 export function Sha256_clone(orig: number): number {
32385 if(!isWasmInitialized) {
32386 throw new Error("initializeWasm() must be awaited first!");
32388 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
32389 return nativeResponseValue;
32391 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
32393 export function Sha256_hash(o: number): bigint {
32394 if(!isWasmInitialized) {
32395 throw new Error("initializeWasm() must be awaited first!");
32397 const nativeResponseValue = wasm.TS_Sha256_hash(o);
32398 return nativeResponseValue;
32400 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
32402 export function Sha256_eq(a: number, b: number): boolean {
32403 if(!isWasmInitialized) {
32404 throw new Error("initializeWasm() must be awaited first!");
32406 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
32407 return nativeResponseValue;
32409 // void Description_free(struct LDKDescription this_obj);
32411 export function Description_free(this_obj: number): void {
32412 if(!isWasmInitialized) {
32413 throw new Error("initializeWasm() must be awaited first!");
32415 const nativeResponseValue = wasm.TS_Description_free(this_obj);
32416 // debug statements here
32418 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
32420 export function Description_clone_ptr(arg: number): number {
32421 if(!isWasmInitialized) {
32422 throw new Error("initializeWasm() must be awaited first!");
32424 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
32425 return nativeResponseValue;
32427 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
32429 export function Description_clone(orig: number): number {
32430 if(!isWasmInitialized) {
32431 throw new Error("initializeWasm() must be awaited first!");
32433 const nativeResponseValue = wasm.TS_Description_clone(orig);
32434 return nativeResponseValue;
32436 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
32438 export function Description_hash(o: number): bigint {
32439 if(!isWasmInitialized) {
32440 throw new Error("initializeWasm() must be awaited first!");
32442 const nativeResponseValue = wasm.TS_Description_hash(o);
32443 return nativeResponseValue;
32445 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
32447 export function Description_eq(a: number, b: number): boolean {
32448 if(!isWasmInitialized) {
32449 throw new Error("initializeWasm() must be awaited first!");
32451 const nativeResponseValue = wasm.TS_Description_eq(a, b);
32452 return nativeResponseValue;
32454 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
32456 export function PayeePubKey_free(this_obj: number): void {
32457 if(!isWasmInitialized) {
32458 throw new Error("initializeWasm() must be awaited first!");
32460 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
32461 // debug statements here
32463 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
32465 export function PayeePubKey_get_a(this_ptr: number): number {
32466 if(!isWasmInitialized) {
32467 throw new Error("initializeWasm() must be awaited first!");
32469 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
32470 return nativeResponseValue;
32472 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32474 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
32475 if(!isWasmInitialized) {
32476 throw new Error("initializeWasm() must be awaited first!");
32478 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
32479 // debug statements here
32481 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
32483 export function PayeePubKey_new(a_arg: number): number {
32484 if(!isWasmInitialized) {
32485 throw new Error("initializeWasm() must be awaited first!");
32487 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
32488 return nativeResponseValue;
32490 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
32492 export function PayeePubKey_clone_ptr(arg: number): number {
32493 if(!isWasmInitialized) {
32494 throw new Error("initializeWasm() must be awaited first!");
32496 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
32497 return nativeResponseValue;
32499 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
32501 export function PayeePubKey_clone(orig: number): number {
32502 if(!isWasmInitialized) {
32503 throw new Error("initializeWasm() must be awaited first!");
32505 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
32506 return nativeResponseValue;
32508 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
32510 export function PayeePubKey_hash(o: number): bigint {
32511 if(!isWasmInitialized) {
32512 throw new Error("initializeWasm() must be awaited first!");
32514 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
32515 return nativeResponseValue;
32517 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
32519 export function PayeePubKey_eq(a: number, b: number): boolean {
32520 if(!isWasmInitialized) {
32521 throw new Error("initializeWasm() must be awaited first!");
32523 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
32524 return nativeResponseValue;
32526 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
32528 export function ExpiryTime_free(this_obj: number): void {
32529 if(!isWasmInitialized) {
32530 throw new Error("initializeWasm() must be awaited first!");
32532 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
32533 // debug statements here
32535 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
32537 export function ExpiryTime_clone_ptr(arg: number): number {
32538 if(!isWasmInitialized) {
32539 throw new Error("initializeWasm() must be awaited first!");
32541 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
32542 return nativeResponseValue;
32544 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
32546 export function ExpiryTime_clone(orig: number): number {
32547 if(!isWasmInitialized) {
32548 throw new Error("initializeWasm() must be awaited first!");
32550 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
32551 return nativeResponseValue;
32553 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
32555 export function ExpiryTime_hash(o: number): bigint {
32556 if(!isWasmInitialized) {
32557 throw new Error("initializeWasm() must be awaited first!");
32559 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
32560 return nativeResponseValue;
32562 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
32564 export function ExpiryTime_eq(a: number, b: number): boolean {
32565 if(!isWasmInitialized) {
32566 throw new Error("initializeWasm() must be awaited first!");
32568 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
32569 return nativeResponseValue;
32571 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
32573 export function MinFinalCltvExpiry_free(this_obj: number): void {
32574 if(!isWasmInitialized) {
32575 throw new Error("initializeWasm() must be awaited first!");
32577 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
32578 // debug statements here
32580 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
32582 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
32583 if(!isWasmInitialized) {
32584 throw new Error("initializeWasm() must be awaited first!");
32586 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
32587 return nativeResponseValue;
32589 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
32591 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
32592 if(!isWasmInitialized) {
32593 throw new Error("initializeWasm() must be awaited first!");
32595 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
32596 // debug statements here
32598 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
32600 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
32601 if(!isWasmInitialized) {
32602 throw new Error("initializeWasm() must be awaited first!");
32604 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
32605 return nativeResponseValue;
32607 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
32609 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
32610 if(!isWasmInitialized) {
32611 throw new Error("initializeWasm() must be awaited first!");
32613 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
32614 return nativeResponseValue;
32616 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
32618 export function MinFinalCltvExpiry_clone(orig: number): number {
32619 if(!isWasmInitialized) {
32620 throw new Error("initializeWasm() must be awaited first!");
32622 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
32623 return nativeResponseValue;
32625 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
32627 export function MinFinalCltvExpiry_hash(o: number): bigint {
32628 if(!isWasmInitialized) {
32629 throw new Error("initializeWasm() must be awaited first!");
32631 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
32632 return nativeResponseValue;
32634 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
32636 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
32637 if(!isWasmInitialized) {
32638 throw new Error("initializeWasm() must be awaited first!");
32640 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
32641 return nativeResponseValue;
32643 // void Fallback_free(struct LDKFallback this_ptr);
32645 export function Fallback_free(this_ptr: number): void {
32646 if(!isWasmInitialized) {
32647 throw new Error("initializeWasm() must be awaited first!");
32649 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
32650 // debug statements here
32652 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
32654 export function Fallback_clone_ptr(arg: number): number {
32655 if(!isWasmInitialized) {
32656 throw new Error("initializeWasm() must be awaited first!");
32658 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
32659 return nativeResponseValue;
32661 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
32663 export function Fallback_clone(orig: number): number {
32664 if(!isWasmInitialized) {
32665 throw new Error("initializeWasm() must be awaited first!");
32667 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
32668 return nativeResponseValue;
32670 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
32672 export function Fallback_seg_wit_program(version: number, program: number): number {
32673 if(!isWasmInitialized) {
32674 throw new Error("initializeWasm() must be awaited first!");
32676 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
32677 return nativeResponseValue;
32679 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
32681 export function Fallback_pub_key_hash(a: number): number {
32682 if(!isWasmInitialized) {
32683 throw new Error("initializeWasm() must be awaited first!");
32685 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
32686 return nativeResponseValue;
32688 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
32690 export function Fallback_script_hash(a: number): number {
32691 if(!isWasmInitialized) {
32692 throw new Error("initializeWasm() must be awaited first!");
32694 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
32695 return nativeResponseValue;
32697 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
32699 export function Fallback_hash(o: number): bigint {
32700 if(!isWasmInitialized) {
32701 throw new Error("initializeWasm() must be awaited first!");
32703 const nativeResponseValue = wasm.TS_Fallback_hash(o);
32704 return nativeResponseValue;
32706 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
32708 export function Fallback_eq(a: number, b: number): boolean {
32709 if(!isWasmInitialized) {
32710 throw new Error("initializeWasm() must be awaited first!");
32712 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
32713 return nativeResponseValue;
32715 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
32717 export function InvoiceSignature_free(this_obj: number): void {
32718 if(!isWasmInitialized) {
32719 throw new Error("initializeWasm() must be awaited first!");
32721 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
32722 // debug statements here
32724 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
32726 export function InvoiceSignature_clone_ptr(arg: number): number {
32727 if(!isWasmInitialized) {
32728 throw new Error("initializeWasm() must be awaited first!");
32730 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
32731 return nativeResponseValue;
32733 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
32735 export function InvoiceSignature_clone(orig: number): number {
32736 if(!isWasmInitialized) {
32737 throw new Error("initializeWasm() must be awaited first!");
32739 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
32740 return nativeResponseValue;
32742 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
32744 export function InvoiceSignature_eq(a: number, b: number): boolean {
32745 if(!isWasmInitialized) {
32746 throw new Error("initializeWasm() must be awaited first!");
32748 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
32749 return nativeResponseValue;
32751 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
32753 export function PrivateRoute_free(this_obj: number): void {
32754 if(!isWasmInitialized) {
32755 throw new Error("initializeWasm() must be awaited first!");
32757 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
32758 // debug statements here
32760 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
32762 export function PrivateRoute_clone_ptr(arg: number): number {
32763 if(!isWasmInitialized) {
32764 throw new Error("initializeWasm() must be awaited first!");
32766 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
32767 return nativeResponseValue;
32769 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
32771 export function PrivateRoute_clone(orig: number): number {
32772 if(!isWasmInitialized) {
32773 throw new Error("initializeWasm() must be awaited first!");
32775 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
32776 return nativeResponseValue;
32778 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
32780 export function PrivateRoute_hash(o: number): bigint {
32781 if(!isWasmInitialized) {
32782 throw new Error("initializeWasm() must be awaited first!");
32784 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
32785 return nativeResponseValue;
32787 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
32789 export function PrivateRoute_eq(a: number, b: number): boolean {
32790 if(!isWasmInitialized) {
32791 throw new Error("initializeWasm() must be awaited first!");
32793 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
32794 return nativeResponseValue;
32796 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
32798 export function SignedRawInvoice_into_parts(this_arg: number): number {
32799 if(!isWasmInitialized) {
32800 throw new Error("initializeWasm() must be awaited first!");
32802 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
32803 return nativeResponseValue;
32805 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32807 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
32808 if(!isWasmInitialized) {
32809 throw new Error("initializeWasm() must be awaited first!");
32811 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
32812 return nativeResponseValue;
32814 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
32816 export function SignedRawInvoice_hash(this_arg: number): number {
32817 if(!isWasmInitialized) {
32818 throw new Error("initializeWasm() must be awaited first!");
32820 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
32821 return nativeResponseValue;
32823 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32825 export function SignedRawInvoice_signature(this_arg: number): number {
32826 if(!isWasmInitialized) {
32827 throw new Error("initializeWasm() must be awaited first!");
32829 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
32830 return nativeResponseValue;
32832 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32834 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
32835 if(!isWasmInitialized) {
32836 throw new Error("initializeWasm() must be awaited first!");
32838 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
32839 return nativeResponseValue;
32841 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32843 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
32844 if(!isWasmInitialized) {
32845 throw new Error("initializeWasm() must be awaited first!");
32847 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
32848 return nativeResponseValue;
32850 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32852 export function RawInvoice_hash(this_arg: number): number {
32853 if(!isWasmInitialized) {
32854 throw new Error("initializeWasm() must be awaited first!");
32856 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
32857 return nativeResponseValue;
32859 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32861 export function RawInvoice_payment_hash(this_arg: number): number {
32862 if(!isWasmInitialized) {
32863 throw new Error("initializeWasm() must be awaited first!");
32865 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
32866 return nativeResponseValue;
32868 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32870 export function RawInvoice_description(this_arg: number): number {
32871 if(!isWasmInitialized) {
32872 throw new Error("initializeWasm() must be awaited first!");
32874 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
32875 return nativeResponseValue;
32877 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32879 export function RawInvoice_payee_pub_key(this_arg: number): number {
32880 if(!isWasmInitialized) {
32881 throw new Error("initializeWasm() must be awaited first!");
32883 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
32884 return nativeResponseValue;
32886 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32888 export function RawInvoice_description_hash(this_arg: number): number {
32889 if(!isWasmInitialized) {
32890 throw new Error("initializeWasm() must be awaited first!");
32892 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
32893 return nativeResponseValue;
32895 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32897 export function RawInvoice_expiry_time(this_arg: number): number {
32898 if(!isWasmInitialized) {
32899 throw new Error("initializeWasm() must be awaited first!");
32901 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
32902 return nativeResponseValue;
32904 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32906 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
32907 if(!isWasmInitialized) {
32908 throw new Error("initializeWasm() must be awaited first!");
32910 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
32911 return nativeResponseValue;
32913 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32915 export function RawInvoice_payment_secret(this_arg: number): number {
32916 if(!isWasmInitialized) {
32917 throw new Error("initializeWasm() must be awaited first!");
32919 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
32920 return nativeResponseValue;
32922 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32924 export function RawInvoice_features(this_arg: number): number {
32925 if(!isWasmInitialized) {
32926 throw new Error("initializeWasm() must be awaited first!");
32928 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
32929 return nativeResponseValue;
32931 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32933 export function RawInvoice_private_routes(this_arg: number): number {
32934 if(!isWasmInitialized) {
32935 throw new Error("initializeWasm() must be awaited first!");
32937 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
32938 return nativeResponseValue;
32940 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32942 export function RawInvoice_amount_pico_btc(this_arg: number): number {
32943 if(!isWasmInitialized) {
32944 throw new Error("initializeWasm() must be awaited first!");
32946 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
32947 return nativeResponseValue;
32949 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32951 export function RawInvoice_currency(this_arg: number): Currency {
32952 if(!isWasmInitialized) {
32953 throw new Error("initializeWasm() must be awaited first!");
32955 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
32956 return nativeResponseValue;
32958 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
32960 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
32961 if(!isWasmInitialized) {
32962 throw new Error("initializeWasm() must be awaited first!");
32964 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
32965 return nativeResponseValue;
32967 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
32969 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
32970 if(!isWasmInitialized) {
32971 throw new Error("initializeWasm() must be awaited first!");
32973 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
32974 return nativeResponseValue;
32976 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32978 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
32979 if(!isWasmInitialized) {
32980 throw new Error("initializeWasm() must be awaited first!");
32982 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
32983 return nativeResponseValue;
32985 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32987 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
32988 if(!isWasmInitialized) {
32989 throw new Error("initializeWasm() must be awaited first!");
32991 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
32992 return nativeResponseValue;
32994 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
32996 export function Invoice_into_signed_raw(this_arg: number): number {
32997 if(!isWasmInitialized) {
32998 throw new Error("initializeWasm() must be awaited first!");
33000 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
33001 return nativeResponseValue;
33003 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
33005 export function Invoice_check_signature(this_arg: number): number {
33006 if(!isWasmInitialized) {
33007 throw new Error("initializeWasm() must be awaited first!");
33009 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
33010 return nativeResponseValue;
33012 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
33014 export function Invoice_from_signed(signed_invoice: number): number {
33015 if(!isWasmInitialized) {
33016 throw new Error("initializeWasm() must be awaited first!");
33018 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
33019 return nativeResponseValue;
33021 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
33023 export function Invoice_duration_since_epoch(this_arg: number): bigint {
33024 if(!isWasmInitialized) {
33025 throw new Error("initializeWasm() must be awaited first!");
33027 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
33028 return nativeResponseValue;
33030 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
33032 export function Invoice_payment_hash(this_arg: number): number {
33033 if(!isWasmInitialized) {
33034 throw new Error("initializeWasm() must be awaited first!");
33036 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
33037 return nativeResponseValue;
33039 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
33041 export function Invoice_payee_pub_key(this_arg: number): number {
33042 if(!isWasmInitialized) {
33043 throw new Error("initializeWasm() must be awaited first!");
33045 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
33046 return nativeResponseValue;
33048 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
33050 export function Invoice_payment_secret(this_arg: number): number {
33051 if(!isWasmInitialized) {
33052 throw new Error("initializeWasm() must be awaited first!");
33054 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
33055 return nativeResponseValue;
33057 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
33059 export function Invoice_features(this_arg: number): number {
33060 if(!isWasmInitialized) {
33061 throw new Error("initializeWasm() must be awaited first!");
33063 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
33064 return nativeResponseValue;
33066 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
33068 export function Invoice_recover_payee_pub_key(this_arg: number): number {
33069 if(!isWasmInitialized) {
33070 throw new Error("initializeWasm() must be awaited first!");
33072 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
33073 return nativeResponseValue;
33075 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
33077 export function Invoice_expiry_time(this_arg: number): bigint {
33078 if(!isWasmInitialized) {
33079 throw new Error("initializeWasm() must be awaited first!");
33081 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
33082 return nativeResponseValue;
33084 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
33086 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
33087 if(!isWasmInitialized) {
33088 throw new Error("initializeWasm() must be awaited first!");
33090 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
33091 return nativeResponseValue;
33093 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
33095 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
33096 if(!isWasmInitialized) {
33097 throw new Error("initializeWasm() must be awaited first!");
33099 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
33100 return nativeResponseValue;
33102 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
33104 export function Invoice_private_routes(this_arg: number): number {
33105 if(!isWasmInitialized) {
33106 throw new Error("initializeWasm() must be awaited first!");
33108 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
33109 return nativeResponseValue;
33111 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
33113 export function Invoice_route_hints(this_arg: number): number {
33114 if(!isWasmInitialized) {
33115 throw new Error("initializeWasm() must be awaited first!");
33117 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
33118 return nativeResponseValue;
33120 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
33122 export function Invoice_currency(this_arg: number): Currency {
33123 if(!isWasmInitialized) {
33124 throw new Error("initializeWasm() must be awaited first!");
33126 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
33127 return nativeResponseValue;
33129 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
33131 export function Invoice_amount_milli_satoshis(this_arg: number): number {
33132 if(!isWasmInitialized) {
33133 throw new Error("initializeWasm() must be awaited first!");
33135 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
33136 return nativeResponseValue;
33138 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
33140 export function Description_new(description: number): number {
33141 if(!isWasmInitialized) {
33142 throw new Error("initializeWasm() must be awaited first!");
33144 const nativeResponseValue = wasm.TS_Description_new(description);
33145 return nativeResponseValue;
33147 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
33149 export function Description_into_inner(this_arg: number): number {
33150 if(!isWasmInitialized) {
33151 throw new Error("initializeWasm() must be awaited first!");
33153 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
33154 return nativeResponseValue;
33156 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
33158 export function ExpiryTime_from_seconds(seconds: bigint): number {
33159 if(!isWasmInitialized) {
33160 throw new Error("initializeWasm() must be awaited first!");
33162 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
33163 return nativeResponseValue;
33165 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
33167 export function ExpiryTime_from_duration(duration: bigint): number {
33168 if(!isWasmInitialized) {
33169 throw new Error("initializeWasm() must be awaited first!");
33171 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
33172 return nativeResponseValue;
33174 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
33176 export function ExpiryTime_as_seconds(this_arg: number): bigint {
33177 if(!isWasmInitialized) {
33178 throw new Error("initializeWasm() must be awaited first!");
33180 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
33181 return nativeResponseValue;
33183 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
33185 export function ExpiryTime_as_duration(this_arg: number): bigint {
33186 if(!isWasmInitialized) {
33187 throw new Error("initializeWasm() must be awaited first!");
33189 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
33190 return nativeResponseValue;
33192 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
33194 export function PrivateRoute_new(hops: number): number {
33195 if(!isWasmInitialized) {
33196 throw new Error("initializeWasm() must be awaited first!");
33198 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
33199 return nativeResponseValue;
33201 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
33203 export function PrivateRoute_into_inner(this_arg: number): number {
33204 if(!isWasmInitialized) {
33205 throw new Error("initializeWasm() must be awaited first!");
33207 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
33208 return nativeResponseValue;
33210 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
33212 export function CreationError_clone(orig: number): CreationError {
33213 if(!isWasmInitialized) {
33214 throw new Error("initializeWasm() must be awaited first!");
33216 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
33217 return nativeResponseValue;
33219 // enum LDKCreationError CreationError_description_too_long(void);
33221 export function CreationError_description_too_long(): CreationError {
33222 if(!isWasmInitialized) {
33223 throw new Error("initializeWasm() must be awaited first!");
33225 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
33226 return nativeResponseValue;
33228 // enum LDKCreationError CreationError_route_too_long(void);
33230 export function CreationError_route_too_long(): CreationError {
33231 if(!isWasmInitialized) {
33232 throw new Error("initializeWasm() must be awaited first!");
33234 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
33235 return nativeResponseValue;
33237 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
33239 export function CreationError_timestamp_out_of_bounds(): CreationError {
33240 if(!isWasmInitialized) {
33241 throw new Error("initializeWasm() must be awaited first!");
33243 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
33244 return nativeResponseValue;
33246 // enum LDKCreationError CreationError_invalid_amount(void);
33248 export function CreationError_invalid_amount(): CreationError {
33249 if(!isWasmInitialized) {
33250 throw new Error("initializeWasm() must be awaited first!");
33252 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
33253 return nativeResponseValue;
33255 // enum LDKCreationError CreationError_missing_route_hints(void);
33257 export function CreationError_missing_route_hints(): CreationError {
33258 if(!isWasmInitialized) {
33259 throw new Error("initializeWasm() must be awaited first!");
33261 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
33262 return nativeResponseValue;
33264 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
33266 export function CreationError_eq(a: number, b: number): boolean {
33267 if(!isWasmInitialized) {
33268 throw new Error("initializeWasm() must be awaited first!");
33270 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
33271 return nativeResponseValue;
33273 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
33275 export function CreationError_to_str(o: number): number {
33276 if(!isWasmInitialized) {
33277 throw new Error("initializeWasm() must be awaited first!");
33279 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
33280 return nativeResponseValue;
33282 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
33284 export function SemanticError_clone(orig: number): SemanticError {
33285 if(!isWasmInitialized) {
33286 throw new Error("initializeWasm() must be awaited first!");
33288 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
33289 return nativeResponseValue;
33291 // enum LDKSemanticError SemanticError_no_payment_hash(void);
33293 export function SemanticError_no_payment_hash(): SemanticError {
33294 if(!isWasmInitialized) {
33295 throw new Error("initializeWasm() must be awaited first!");
33297 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
33298 return nativeResponseValue;
33300 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
33302 export function SemanticError_multiple_payment_hashes(): SemanticError {
33303 if(!isWasmInitialized) {
33304 throw new Error("initializeWasm() must be awaited first!");
33306 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
33307 return nativeResponseValue;
33309 // enum LDKSemanticError SemanticError_no_description(void);
33311 export function SemanticError_no_description(): SemanticError {
33312 if(!isWasmInitialized) {
33313 throw new Error("initializeWasm() must be awaited first!");
33315 const nativeResponseValue = wasm.TS_SemanticError_no_description();
33316 return nativeResponseValue;
33318 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
33320 export function SemanticError_multiple_descriptions(): SemanticError {
33321 if(!isWasmInitialized) {
33322 throw new Error("initializeWasm() must be awaited first!");
33324 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
33325 return nativeResponseValue;
33327 // enum LDKSemanticError SemanticError_no_payment_secret(void);
33329 export function SemanticError_no_payment_secret(): SemanticError {
33330 if(!isWasmInitialized) {
33331 throw new Error("initializeWasm() must be awaited first!");
33333 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
33334 return nativeResponseValue;
33336 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
33338 export function SemanticError_multiple_payment_secrets(): SemanticError {
33339 if(!isWasmInitialized) {
33340 throw new Error("initializeWasm() must be awaited first!");
33342 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
33343 return nativeResponseValue;
33345 // enum LDKSemanticError SemanticError_invalid_features(void);
33347 export function SemanticError_invalid_features(): SemanticError {
33348 if(!isWasmInitialized) {
33349 throw new Error("initializeWasm() must be awaited first!");
33351 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
33352 return nativeResponseValue;
33354 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
33356 export function SemanticError_invalid_recovery_id(): SemanticError {
33357 if(!isWasmInitialized) {
33358 throw new Error("initializeWasm() must be awaited first!");
33360 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
33361 return nativeResponseValue;
33363 // enum LDKSemanticError SemanticError_invalid_signature(void);
33365 export function SemanticError_invalid_signature(): SemanticError {
33366 if(!isWasmInitialized) {
33367 throw new Error("initializeWasm() must be awaited first!");
33369 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
33370 return nativeResponseValue;
33372 // enum LDKSemanticError SemanticError_imprecise_amount(void);
33374 export function SemanticError_imprecise_amount(): SemanticError {
33375 if(!isWasmInitialized) {
33376 throw new Error("initializeWasm() must be awaited first!");
33378 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
33379 return nativeResponseValue;
33381 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
33383 export function SemanticError_eq(a: number, b: number): boolean {
33384 if(!isWasmInitialized) {
33385 throw new Error("initializeWasm() must be awaited first!");
33387 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
33388 return nativeResponseValue;
33390 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
33392 export function SemanticError_to_str(o: number): number {
33393 if(!isWasmInitialized) {
33394 throw new Error("initializeWasm() must be awaited first!");
33396 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
33397 return nativeResponseValue;
33399 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
33401 export function SignOrCreationError_free(this_ptr: number): void {
33402 if(!isWasmInitialized) {
33403 throw new Error("initializeWasm() must be awaited first!");
33405 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
33406 // debug statements here
33408 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
33410 export function SignOrCreationError_clone_ptr(arg: number): number {
33411 if(!isWasmInitialized) {
33412 throw new Error("initializeWasm() must be awaited first!");
33414 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
33415 return nativeResponseValue;
33417 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
33419 export function SignOrCreationError_clone(orig: number): number {
33420 if(!isWasmInitialized) {
33421 throw new Error("initializeWasm() must be awaited first!");
33423 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
33424 return nativeResponseValue;
33426 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
33428 export function SignOrCreationError_sign_error(): number {
33429 if(!isWasmInitialized) {
33430 throw new Error("initializeWasm() must be awaited first!");
33432 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
33433 return nativeResponseValue;
33435 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
33437 export function SignOrCreationError_creation_error(a: CreationError): number {
33438 if(!isWasmInitialized) {
33439 throw new Error("initializeWasm() must be awaited first!");
33441 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
33442 return nativeResponseValue;
33444 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
33446 export function SignOrCreationError_eq(a: number, b: number): boolean {
33447 if(!isWasmInitialized) {
33448 throw new Error("initializeWasm() must be awaited first!");
33450 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
33451 return nativeResponseValue;
33453 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
33455 export function SignOrCreationError_to_str(o: number): number {
33456 if(!isWasmInitialized) {
33457 throw new Error("initializeWasm() must be awaited first!");
33459 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
33460 return nativeResponseValue;
33462 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
33464 export function InvoicePayer_free(this_obj: number): void {
33465 if(!isWasmInitialized) {
33466 throw new Error("initializeWasm() must be awaited first!");
33468 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
33469 // debug statements here
33471 // void Payer_free(struct LDKPayer this_ptr);
33473 export function Payer_free(this_ptr: number): void {
33474 if(!isWasmInitialized) {
33475 throw new Error("initializeWasm() must be awaited first!");
33477 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
33478 // debug statements here
33480 // void Router_free(struct LDKRouter this_ptr);
33482 export function Router_free(this_ptr: number): void {
33483 if(!isWasmInitialized) {
33484 throw new Error("initializeWasm() must be awaited first!");
33486 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
33487 // debug statements here
33489 // void Retry_free(struct LDKRetry this_ptr);
33491 export function Retry_free(this_ptr: number): void {
33492 if(!isWasmInitialized) {
33493 throw new Error("initializeWasm() must be awaited first!");
33495 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
33496 // debug statements here
33498 // uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
33500 export function Retry_clone_ptr(arg: number): number {
33501 if(!isWasmInitialized) {
33502 throw new Error("initializeWasm() must be awaited first!");
33504 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
33505 return nativeResponseValue;
33507 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
33509 export function Retry_clone(orig: number): number {
33510 if(!isWasmInitialized) {
33511 throw new Error("initializeWasm() must be awaited first!");
33513 const nativeResponseValue = wasm.TS_Retry_clone(orig);
33514 return nativeResponseValue;
33516 // struct LDKRetry Retry_attempts(uintptr_t a);
33518 export function Retry_attempts(a: number): number {
33519 if(!isWasmInitialized) {
33520 throw new Error("initializeWasm() must be awaited first!");
33522 const nativeResponseValue = wasm.TS_Retry_attempts(a);
33523 return nativeResponseValue;
33525 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
33527 export function Retry_eq(a: number, b: number): boolean {
33528 if(!isWasmInitialized) {
33529 throw new Error("initializeWasm() must be awaited first!");
33531 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
33532 return nativeResponseValue;
33534 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
33536 export function Retry_hash(o: number): bigint {
33537 if(!isWasmInitialized) {
33538 throw new Error("initializeWasm() must be awaited first!");
33540 const nativeResponseValue = wasm.TS_Retry_hash(o);
33541 return nativeResponseValue;
33543 // void PaymentError_free(struct LDKPaymentError this_ptr);
33545 export function PaymentError_free(this_ptr: number): void {
33546 if(!isWasmInitialized) {
33547 throw new Error("initializeWasm() must be awaited first!");
33549 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
33550 // debug statements here
33552 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
33554 export function PaymentError_clone_ptr(arg: number): number {
33555 if(!isWasmInitialized) {
33556 throw new Error("initializeWasm() must be awaited first!");
33558 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
33559 return nativeResponseValue;
33561 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
33563 export function PaymentError_clone(orig: number): number {
33564 if(!isWasmInitialized) {
33565 throw new Error("initializeWasm() must be awaited first!");
33567 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
33568 return nativeResponseValue;
33570 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
33572 export function PaymentError_invoice(a: number): number {
33573 if(!isWasmInitialized) {
33574 throw new Error("initializeWasm() must be awaited first!");
33576 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
33577 return nativeResponseValue;
33579 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
33581 export function PaymentError_routing(a: number): number {
33582 if(!isWasmInitialized) {
33583 throw new Error("initializeWasm() must be awaited first!");
33585 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
33586 return nativeResponseValue;
33588 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
33590 export function PaymentError_sending(a: number): number {
33591 if(!isWasmInitialized) {
33592 throw new Error("initializeWasm() must be awaited first!");
33594 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
33595 return nativeResponseValue;
33597 // 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);
33599 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry: number): number {
33600 if(!isWasmInitialized) {
33601 throw new Error("initializeWasm() must be awaited first!");
33603 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
33604 return nativeResponseValue;
33606 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
33608 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
33609 if(!isWasmInitialized) {
33610 throw new Error("initializeWasm() must be awaited first!");
33612 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
33613 return nativeResponseValue;
33615 // 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);
33617 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
33618 if(!isWasmInitialized) {
33619 throw new Error("initializeWasm() must be awaited first!");
33621 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
33622 return nativeResponseValue;
33624 // 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);
33626 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
33627 if(!isWasmInitialized) {
33628 throw new Error("initializeWasm() must be awaited first!");
33630 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
33631 return nativeResponseValue;
33633 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
33635 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
33636 if(!isWasmInitialized) {
33637 throw new Error("initializeWasm() must be awaited first!");
33639 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
33640 // debug statements here
33642 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
33644 export function InvoicePayer_as_EventHandler(this_arg: number): number {
33645 if(!isWasmInitialized) {
33646 throw new Error("initializeWasm() must be awaited first!");
33648 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
33649 return nativeResponseValue;
33651 // 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);
33653 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: number, keys_manager: number, network: Currency, amt_msat: number, description_hash: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): number {
33654 if(!isWasmInitialized) {
33655 throw new Error("initializeWasm() must be awaited first!");
33657 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);
33658 return nativeResponseValue;
33660 // 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);
33662 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: number, keys_manager: number, network: Currency, amt_msat: number, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): number {
33663 if(!isWasmInitialized) {
33664 throw new Error("initializeWasm() must be awaited first!");
33666 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);
33667 return nativeResponseValue;
33669 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
33671 export function DefaultRouter_free(this_obj: number): void {
33672 if(!isWasmInitialized) {
33673 throw new Error("initializeWasm() must be awaited first!");
33675 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
33676 // debug statements here
33678 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
33680 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
33681 if(!isWasmInitialized) {
33682 throw new Error("initializeWasm() must be awaited first!");
33684 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
33685 return nativeResponseValue;
33687 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
33689 export function DefaultRouter_as_Router(this_arg: number): number {
33690 if(!isWasmInitialized) {
33691 throw new Error("initializeWasm() must be awaited first!");
33693 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
33694 return nativeResponseValue;
33696 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
33698 export function ChannelManager_as_Payer(this_arg: number): number {
33699 if(!isWasmInitialized) {
33700 throw new Error("initializeWasm() must be awaited first!");
33702 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
33703 return nativeResponseValue;
33705 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
33707 export function SiPrefix_from_str(s: number): number {
33708 if(!isWasmInitialized) {
33709 throw new Error("initializeWasm() must be awaited first!");
33711 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
33712 return nativeResponseValue;
33714 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
33716 export function Invoice_from_str(s: number): number {
33717 if(!isWasmInitialized) {
33718 throw new Error("initializeWasm() must be awaited first!");
33720 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
33721 return nativeResponseValue;
33723 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
33725 export function SignedRawInvoice_from_str(s: number): number {
33726 if(!isWasmInitialized) {
33727 throw new Error("initializeWasm() must be awaited first!");
33729 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
33730 return nativeResponseValue;
33732 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
33734 export function ParseError_to_str(o: number): number {
33735 if(!isWasmInitialized) {
33736 throw new Error("initializeWasm() must be awaited first!");
33738 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
33739 return nativeResponseValue;
33741 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
33743 export function ParseOrSemanticError_to_str(o: number): number {
33744 if(!isWasmInitialized) {
33745 throw new Error("initializeWasm() must be awaited first!");
33747 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
33748 return nativeResponseValue;
33750 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
33752 export function Invoice_to_str(o: number): number {
33753 if(!isWasmInitialized) {
33754 throw new Error("initializeWasm() must be awaited first!");
33756 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
33757 return nativeResponseValue;
33759 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
33761 export function SignedRawInvoice_to_str(o: number): number {
33762 if(!isWasmInitialized) {
33763 throw new Error("initializeWasm() must be awaited first!");
33765 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
33766 return nativeResponseValue;
33768 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
33770 export function Currency_to_str(o: number): number {
33771 if(!isWasmInitialized) {
33772 throw new Error("initializeWasm() must be awaited first!");
33774 const nativeResponseValue = wasm.TS_Currency_to_str(o);
33775 return nativeResponseValue;
33777 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
33779 export function SiPrefix_to_str(o: number): number {
33780 if(!isWasmInitialized) {
33781 throw new Error("initializeWasm() must be awaited first!");
33783 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
33784 return nativeResponseValue;
33788 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) {
33789 const weak: WeakRef<object> = js_objs[obj_ptr];
33790 if (weak == null || weak == undefined) {
33791 console.error("Got function call on unknown/free'd JS object!");
33792 throw new Error("Got function call on unknown/free'd JS object!");
33794 const obj: object = weak.deref();
33795 if (obj == null || obj == undefined) {
33796 console.error("Got function call on GC'd JS object!");
33797 throw new Error("Got function call on GC'd JS object!");
33801 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
33802 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
33803 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
33804 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
33805 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
33806 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
33807 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
33808 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
33809 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
33810 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
33811 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
33812 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
33813 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
33814 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
33815 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
33816 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33817 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
33818 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
33819 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
33820 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
33821 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
33822 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
33823 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
33824 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
33825 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
33826 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
33827 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
33828 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
33829 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
33830 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
33831 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
33832 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33833 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
33834 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
33835 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
33836 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
33837 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
33838 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
33839 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
33840 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
33841 case 40: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
33842 case 41: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
33843 case 42: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33844 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
33845 case 44: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
33846 case 45: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
33847 case 46: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
33848 case 47: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
33849 case 48: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
33850 case 49: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
33851 case 50: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
33852 case 51: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
33853 case 52: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
33854 case 53: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
33855 case 54: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
33856 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
33857 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
33858 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
33859 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
33860 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
33861 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
33862 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
33863 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
33864 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
33865 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
33866 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
33867 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
33868 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
33869 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
33870 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
33871 case 70: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
33872 case 71: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33873 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
33874 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33875 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
33876 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
33877 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
33878 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33879 case 78: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
33880 case 79: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
33881 case 80: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33882 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
33883 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
33884 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
33885 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
33886 case 85: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
33887 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
33888 case 87: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
33889 case 88: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
33890 case 89: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
33891 case 90: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
33892 case 91: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
33893 case 92: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
33894 case 93: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
33895 case 94: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
33896 case 95: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
33897 case 96: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
33898 case 97: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
33899 case 98: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
33900 case 99: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
33902 console.error("Got unknown function call from C!");
33903 throw new Error("Got unknown function call from C!");
33905 if (fn == null || fn == undefined) {
33906 console.error("Got function call on incorrect JS object!");
33907 throw new Error("Got function call on incorrect JS object!");
33909 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
33910 if (ret === undefined || ret === null) return BigInt(0);
33911 return BigInt(ret);